@gusto/baerly-storage 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (115) hide show
  1. package/README.md +97 -0
  2. package/dist/API.md +850 -0
  3. package/dist/app-config-Cb5dO2s9.d.ts +480 -0
  4. package/dist/app-config.d.ts +2 -0
  5. package/dist/app-config.js +8 -0
  6. package/dist/app-config.js.map +1 -0
  7. package/dist/auth.d.ts +237 -0
  8. package/dist/auth.js +1335 -0
  9. package/dist/auth.js.map +1 -0
  10. package/dist/baerly.js +761 -0
  11. package/dist/baerly.js.map +1 -0
  12. package/dist/bucket-uri-BrDEYvzy.js +4922 -0
  13. package/dist/bucket-uri-BrDEYvzy.js.map +1 -0
  14. package/dist/chunk-EAsCxrDo.js +14 -0
  15. package/dist/client-BLf3Ae5s.d.ts +233 -0
  16. package/dist/client-react.d.ts +131 -0
  17. package/dist/client-react.js +559 -0
  18. package/dist/client-react.js.map +1 -0
  19. package/dist/client.d.ts +4 -0
  20. package/dist/client.js +160 -0
  21. package/dist/client.js.map +1 -0
  22. package/dist/cloudflare-CINJPKCW.js +911 -0
  23. package/dist/cloudflare-CINJPKCW.js.map +1 -0
  24. package/dist/cloudflare.d.ts +211 -0
  25. package/dist/cloudflare.js +445 -0
  26. package/dist/cloudflare.js.map +1 -0
  27. package/dist/config-Bsg8wgwo.js +198 -0
  28. package/dist/config-Bsg8wgwo.js.map +1 -0
  29. package/dist/context-Oj7ffwD-.js +187 -0
  30. package/dist/context-Oj7ffwD-.js.map +1 -0
  31. package/dist/cost-B1WiZxlf.js +203 -0
  32. package/dist/cost-B1WiZxlf.js.map +1 -0
  33. package/dist/current-json-BkatBzF7.js +252 -0
  34. package/dist/current-json-BkatBzF7.js.map +1 -0
  35. package/dist/db-D62JguBc.d.ts +336 -0
  36. package/dist/deploy-BB-wqbhf.js +83 -0
  37. package/dist/deploy-BB-wqbhf.js.map +1 -0
  38. package/dist/dev-banner-CWHIk8tH.d.ts +26 -0
  39. package/dist/dev-vite.d.ts +146 -0
  40. package/dist/dev-vite.js +223 -0
  41. package/dist/dev-vite.js.map +1 -0
  42. package/dist/dev.d.ts +3 -0
  43. package/dist/dev.js +2 -0
  44. package/dist/doctor-B8h9GCN9.js +331 -0
  45. package/dist/doctor-B8h9GCN9.js.map +1 -0
  46. package/dist/dump-BHo_sIMZ.js +116 -0
  47. package/dist/dump-BHo_sIMZ.js.map +1 -0
  48. package/dist/errors-DOdL95kK.js +58 -0
  49. package/dist/errors-DOdL95kK.js.map +1 -0
  50. package/dist/export-Dz2PZKSR.js +423 -0
  51. package/dist/export-Dz2PZKSR.js.map +1 -0
  52. package/dist/fsck-DEz9lyCy.js +293 -0
  53. package/dist/fsck-DEz9lyCy.js.map +1 -0
  54. package/dist/http-CjUO1Bec.js +1756 -0
  55. package/dist/http-CjUO1Bec.js.map +1 -0
  56. package/dist/http.d.ts +1619 -0
  57. package/dist/http.js +2 -0
  58. package/dist/index-BGC-ENnj.d.ts +1065 -0
  59. package/dist/index-BYv0hb8M.d.ts +1457 -0
  60. package/dist/index-BquQkhJi.d.ts +112 -0
  61. package/dist/index-COsQ-Mlz.d.ts +146 -0
  62. package/dist/index.d.ts +6 -0
  63. package/dist/index.js +6 -0
  64. package/dist/indexes-BXn7a06a.js +297 -0
  65. package/dist/indexes-BXn7a06a.js.map +1 -0
  66. package/dist/indexes-DwOXkn1Y.d.ts +22 -0
  67. package/dist/inspect-x02aFWnh.js +149 -0
  68. package/dist/inspect-x02aFWnh.js.map +1 -0
  69. package/dist/log-walk-DIru96UT.js +260 -0
  70. package/dist/log-walk-DIru96UT.js.map +1 -0
  71. package/dist/maintenance-Bn6ul9aV.js +758 -0
  72. package/dist/maintenance-Bn6ul9aV.js.map +1 -0
  73. package/dist/maintenance.d.ts +323 -0
  74. package/dist/maintenance.js +2 -0
  75. package/dist/node.d.ts +422 -0
  76. package/dist/node.js +2 -0
  77. package/dist/normalize-XWY25_sG.js +133 -0
  78. package/dist/normalize-XWY25_sG.js.map +1 -0
  79. package/dist/observability-2IDYRuZK.js +2333 -0
  80. package/dist/observability-2IDYRuZK.js.map +1 -0
  81. package/dist/observability.d.ts +3 -0
  82. package/dist/observability.js +3 -0
  83. package/dist/plan-Cs17VqjU.js +224 -0
  84. package/dist/plan-Cs17VqjU.js.map +1 -0
  85. package/dist/query-DcSbFLJt.js +1880 -0
  86. package/dist/query-DcSbFLJt.js.map +1 -0
  87. package/dist/rebuild-index-C5gTXryd.js +119 -0
  88. package/dist/rebuild-index-C5gTXryd.js.map +1 -0
  89. package/dist/rebuild-index-DwXM0WfA.js +104 -0
  90. package/dist/rebuild-index-DwXM0WfA.js.map +1 -0
  91. package/dist/request-BEF_OvMh.js +72 -0
  92. package/dist/request-BEF_OvMh.js.map +1 -0
  93. package/dist/restore-CbKVMMpm.js +847 -0
  94. package/dist/restore-CbKVMMpm.js.map +1 -0
  95. package/dist/shared-secret-BJdSwpgw.js +71 -0
  96. package/dist/shared-secret-BJdSwpgw.js.map +1 -0
  97. package/dist/snapshot-D7C4_FSl.js +71 -0
  98. package/dist/snapshot-D7C4_FSl.js.map +1 -0
  99. package/dist/snapshot-z_N9hpTe.js +917 -0
  100. package/dist/snapshot-z_N9hpTe.js.map +1 -0
  101. package/dist/src-Chafbw8r.js +522 -0
  102. package/dist/src-Chafbw8r.js.map +1 -0
  103. package/dist/src-DyET_VPP.js +6199 -0
  104. package/dist/src-DyET_VPP.js.map +1 -0
  105. package/dist/src-n0Te1r98.js +352 -0
  106. package/dist/src-n0Te1r98.js.map +1 -0
  107. package/dist/subcommand-BWs6K7zb.js +110 -0
  108. package/dist/subcommand-BWs6K7zb.js.map +1 -0
  109. package/dist/usage-RVUQMLop.js +339 -0
  110. package/dist/usage-RVUQMLop.js.map +1 -0
  111. package/dist/validate-DhH1lO8I.js +377 -0
  112. package/dist/validate-DhH1lO8I.js.map +1 -0
  113. package/dist/wire-izfGZDvr.js +7 -0
  114. package/dist/wire-izfGZDvr.js.map +1 -0
  115. package/package.json +189 -0
package/dist/http.d.ts ADDED
@@ -0,0 +1,1619 @@
1
+ import { r as BaerlyConfig } from "./app-config-Cb5dO2s9.js";
2
+ import { n as LogEntry, s as BaerlyErrorCode } from "./index-BGC-ENnj.js";
3
+ import { t as Db } from "./db-D62JguBc.js";
4
+
5
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/request/constants.d.ts
6
+ declare const GET_MATCH_RESULT: unique symbol;
7
+ //#endregion
8
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/router.d.ts
9
+ /**
10
+ * Interface representing a router.
11
+ *
12
+ * @template T - The type of the handler.
13
+ */
14
+ interface Router<T> {
15
+ /**
16
+ * The name of the router.
17
+ */
18
+ name: string;
19
+ /**
20
+ * Adds a route to the router.
21
+ *
22
+ * @param method - The HTTP method (e.g., 'get', 'post').
23
+ * @param path - The path for the route.
24
+ * @param handler - The handler for the route.
25
+ */
26
+ add(method: string, path: string, handler: T): void;
27
+ /**
28
+ * Matches a route based on the given method and path.
29
+ *
30
+ * @param method - The HTTP method (e.g., 'get', 'post').
31
+ * @param path - The path to match.
32
+ * @returns The result of the match.
33
+ */
34
+ match(method: string, path: string): Result<T>;
35
+ }
36
+ /**
37
+ * Type representing a map of parameter indices.
38
+ */
39
+ type ParamIndexMap = Record<string, number>;
40
+ /**
41
+ * Type representing a stash of parameters.
42
+ */
43
+ type ParamStash = string[];
44
+ /**
45
+ * Type representing a map of parameters.
46
+ */
47
+ type Params = Record<string, string>;
48
+ /**
49
+ * Type representing the result of a route match.
50
+ *
51
+ * The result can be in one of two formats:
52
+ * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
53
+ * 2. An array of handlers with their corresponding parameter maps.
54
+ *
55
+ * Example:
56
+ *
57
+ * [[handler, paramIndexMap][], paramArray]
58
+ * ```typescript
59
+ * [
60
+ * [
61
+ * [middlewareA, {}], // '*'
62
+ * [funcA, {'id': 0}], // '/user/:id/*'
63
+ * [funcB, {'id': 0, 'action': 1}], // '/user/:id/:action'
64
+ * ],
65
+ * ['123', 'abc']
66
+ * ]
67
+ * ```
68
+ *
69
+ * [[handler, params][]]
70
+ * ```typescript
71
+ * [
72
+ * [
73
+ * [middlewareA, {}], // '*'
74
+ * [funcA, {'id': '123'}], // '/user/:id/*'
75
+ * [funcB, {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
76
+ * ]
77
+ * ]
78
+ * ```
79
+ */
80
+ type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
81
+ //#endregion
82
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/utils/headers.d.ts
83
+ /**
84
+ * @module
85
+ * HTTP Headers utility.
86
+ */
87
+ 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';
88
+ 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';
89
+ type CustomHeader = string & {};
90
+ //#endregion
91
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/utils/http-status.d.ts
92
+ /**
93
+ * @module
94
+ * HTTP Status utility.
95
+ */
96
+ type InfoStatusCode = 100 | 101 | 102 | 103;
97
+ type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
98
+ type DeprecatedStatusCode = 305 | 306;
99
+ type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
100
+ 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;
101
+ type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
102
+ /**
103
+ * `UnofficialStatusCode` can be used to specify an unofficial status code.
104
+ * @example
105
+ *
106
+ * ```ts
107
+ * app.get('/unknown', (c) => {
108
+ * return c.text("Unknown Error", 520 as UnofficialStatusCode)
109
+ * })
110
+ * ```
111
+ */
112
+ type UnofficialStatusCode = -1;
113
+ /**
114
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
115
+ */
116
+ type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
117
+ type ContentlessStatusCode = 101 | 204 | 205 | 304;
118
+ type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;
119
+ //#endregion
120
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/utils/types.d.ts
121
+ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
122
+ type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? (K extends string ? T : never) : never;
123
+ type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
124
+ type JSONPrimitive = string | boolean | number | null;
125
+ type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
126
+ type JSONObject = {
127
+ [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
128
+ };
129
+ type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
130
+ type InvalidToNull<T> = T extends InvalidJSONValue ? null : T;
131
+ type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
132
+ /**
133
+ * symbol keys are omitted through `JSON.stringify`
134
+ */
135
+ type OmitSymbolKeys<T> = { [K in keyof T as K extends symbol ? never : K]: T[K] };
136
+ type JSONValue = JSONObject | JSONArray | JSONPrimitive;
137
+ /**
138
+ * Convert a type to a JSON-compatible type.
139
+ *
140
+ * Non-JSON values such as `Date` implement `.toJSON()`,
141
+ * so they can be transformed to a value assignable to `JSONObject`
142
+ *
143
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
144
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
145
+ *
146
+ * This behaviour can be controlled by the `TError` generic type parameter,
147
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
148
+ * You can set it to `never` to disable this check.
149
+ */
150
+ type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
151
+ toJSON(): infer J;
152
+ } ? (() => J) extends (() => JSONPrimitive) ? J : (() => J) extends (() => {
153
+ toJSON(): unknown;
154
+ }) ? {} : 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;
155
+ /**
156
+ * 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.
157
+ * @copyright from sindresorhus/type-fest
158
+ */
159
+ type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
160
+ type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
161
+ //#endregion
162
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/types.d.ts
163
+ type Bindings = object;
164
+ type Variables = object;
165
+ type BlankEnv = {};
166
+ type Env = {
167
+ Bindings?: Bindings;
168
+ Variables?: Variables;
169
+ };
170
+ type Next = () => Promise<void>;
171
+ type ExtractInput<I extends Input | Input['in']> = I extends Input ? unknown extends I['in'] ? {} : I['in'] : I;
172
+ type Input = {
173
+ in?: {};
174
+ out?: {};
175
+ outputFormat?: ResponseFormat;
176
+ };
177
+ type BlankSchema = {};
178
+ type BlankInput = {};
179
+ interface RouterRoute {
180
+ basePath: string;
181
+ path: string;
182
+ method: string;
183
+ handler: H;
184
+ }
185
+ type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>> | Promise<void>;
186
+ 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;
187
+ 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>;
188
+ 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>;
189
+ /**
190
+ * You can extend this interface to define a custom `c.notFound()` Response type.
191
+ *
192
+ * @example
193
+ * declare module 'hono' {
194
+ * interface NotFoundResponse extends Response, TypedResponse<string, 404, 'text'> {}
195
+ * }
196
+ */
197
+ interface NotFoundResponse {}
198
+ type NotFoundHandler<E extends Env = any> = (c: Context<E>) => NotFoundResponse extends Response ? NotFoundResponse | Promise<NotFoundResponse> : Response | Promise<Response>;
199
+ interface HTTPResponseError extends Error {
200
+ getResponse: () => Response;
201
+ }
202
+ type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
203
+ interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/', CurrentPath extends string = BasePath> {
204
+ <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>;
205
+ <P extends string = CurrentPath, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, P, I> = H<E2, P, I>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath, CurrentPath>;
206
+ <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>>;
207
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath, CurrentPath>;
208
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1>, S, M, P, I2, BasePath>, BasePath, MergePath<BasePath, P>>;
209
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath, CurrentPath>;
210
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>, S, M, P, I3, BasePath>, BasePath, MergePath<BasePath, P>>;
211
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4> & M4, H<E6, P, I5, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath, CurrentPath>;
212
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>, S, M, P, I4, BasePath>, BasePath, MergePath<BasePath, P>>;
213
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4> & M4, H<E6, P, I5> & M5, H<E7, P, I6, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, P, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath, CurrentPath>;
214
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4> & M4, H<E6, MergedPath, I5, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>, S, M, P, I5, BasePath>, BasePath, MergePath<BasePath, P>>;
215
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4> & M4, H<E6, P, I5> & M5, H<E7, P, I6> & M6, H<E8, P, I7, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, P, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath, CurrentPath>;
216
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4> & M4, H<E6, MergedPath, I5> & M5, H<E7, MergedPath, I6, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>, S, M, P, I6, BasePath>, BasePath, MergePath<BasePath, P>>;
217
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>, M7 extends H<E8, P, I7> = H<E8, P, I7>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4> & M4, H<E6, P, I5> & M5, H<E7, P, I6> & M6, H<E8, P, I7> & M7, H<E9, P, I8, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, P, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath, CurrentPath>;
218
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4> & M4, H<E6, MergedPath, I5> & M5, H<E7, MergedPath, I6> & M6, H<E8, MergedPath, I7, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>, S, M, P, I7, BasePath>, BasePath, MergePath<BasePath, P>>;
219
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>, M7 extends H<E8, P, I7> = H<E8, P, I7>, M8 extends H<E9, P, I8> = H<E9, P, I8>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4> & M4, H<E6, P, I5> & M5, H<E7, P, I6> & M6, H<E8, P, I7> & M7, H<E9, P, I8> & M8, H<E10, P, I9, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, P, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath, CurrentPath>;
220
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4> & M4, H<E6, MergedPath, I5> & M5, H<E7, MergedPath, I6> & M6, H<E8, MergedPath, I7> & M7, H<E9, MergedPath, I8, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>, S, M, P, I8, BasePath>, BasePath, MergePath<BasePath, P>>;
221
+ <P extends string = CurrentPath, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, M1 extends H<E2, P, I> = H<E2, P, I>, M2 extends H<E3, P, I2> = H<E3, P, I2>, M3 extends H<E4, P, I3> = H<E4, P, I3>, M4 extends H<E5, P, I4> = H<E5, P, I4>, M5 extends H<E6, P, I5> = H<E6, P, I5>, M6 extends H<E7, P, I6> = H<E7, P, I6>, M7 extends H<E8, P, I7> = H<E8, P, I7>, M8 extends H<E9, P, I8> = H<E9, P, I8>, M9 extends H<E10, P, I9> = H<E10, P, I9>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4> & M4, H<E6, P, I5> & M5, H<E7, P, I6> & M6, H<E8, P, I7> & M7, H<E9, P, I8> & M8, H<E10, P, I9> & M9, H<E11, P, I10, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath, CurrentPath>;
222
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4> & M4, H<E6, MergedPath, I5> & M5, H<E7, MergedPath, I6> & M6, H<E8, MergedPath, I7> & M7, H<E9, MergedPath, I8> & M8, H<E10, MergedPath, I9, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>, S, M, P, I9, BasePath>, BasePath, MergePath<BasePath, P>>;
223
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>, M9 extends H<E10, MergedPath, I9> = H<E10, MergedPath, I9>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3> & M3, H<E5, MergedPath, I4> & M4, H<E6, MergedPath, I5> & M5, H<E7, MergedPath, I6> & M6, H<E8, MergedPath, I7> & M7, H<E9, MergedPath, I8> & M8, H<E10, MergedPath, I9> & M9, H<E11, MergedPath, I10, R>]): Hono$1<E, AddSchemaIfHasResponse<MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>, S, M, P, I10, BasePath>, BasePath, MergePath<BasePath, P>>;
224
+ <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>;
225
+ <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>>;
226
+ <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>>;
227
+ }
228
+ interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
229
+ <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, '*'>>[]): Hono$1<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergePath<BasePath, '*'>>;
230
+ <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, '*'>>): Hono$1<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergePath<BasePath, '*'>>;
231
+ <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>;
232
+ <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>;
233
+ <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>;
234
+ <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>;
235
+ <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>;
236
+ <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>;
237
+ <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>;
238
+ <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>;
239
+ <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>;
240
+ <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>;
241
+ <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>;
242
+ <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>;
243
+ <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>;
244
+ <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>;
245
+ <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>;
246
+ <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>;
247
+ <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>;
248
+ <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>;
249
+ <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono$1<E, S, BasePath, MergePath<BasePath, P>>;
250
+ }
251
+ interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
252
+ <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>>;
253
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath, MergePath<BasePath, P>>;
254
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath, MergePath<BasePath, P>>;
255
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath, MergePath<BasePath, P>>;
256
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath, MergePath<BasePath, P>>;
257
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath, MergePath<BasePath, P>>;
258
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath, MergePath<BasePath, P>>;
259
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath, MergePath<BasePath, P>>;
260
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath, MergePath<BasePath, P>>;
261
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>, M9 extends H<E10, MergedPath, I9> = H<E10, MergedPath, I9>>(method: M, 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath, MergePath<BasePath, P>>;
262
+ <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>>;
263
+ <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>>;
264
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>>(methods: M[], path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath, MergePath<BasePath, P>>;
265
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>>(methods: M[], path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3, R>]): Hono$1<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath, MergePath<BasePath, P>>;
266
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath, MergePath<BasePath, P>>;
267
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath, MergePath<BasePath, P>>;
268
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath, MergePath<BasePath, P>>;
269
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath, MergePath<BasePath, P>>;
270
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath, MergePath<BasePath, P>>;
271
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath, MergePath<BasePath, P>>;
272
+ <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]>, M1 extends H<E2, MergedPath, I> = H<E2, MergedPath, I>, M2 extends H<E3, MergedPath, I2> = H<E3, MergedPath, I2>, M3 extends H<E4, MergedPath, I3> = H<E4, MergedPath, I3>, M4 extends H<E5, MergedPath, I4> = H<E5, MergedPath, I4>, M5 extends H<E6, MergedPath, I5> = H<E6, MergedPath, I5>, M6 extends H<E7, MergedPath, I6> = H<E7, MergedPath, I6>, M7 extends H<E8, MergedPath, I7> = H<E8, MergedPath, I7>, M8 extends H<E9, MergedPath, I8> = H<E9, MergedPath, I8>, M9 extends H<E10, MergedPath, I9> = H<E10, MergedPath, I9>>(methods: M[], 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<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath, MergePath<BasePath, P>>;
273
+ <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>>;
274
+ <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>;
275
+ }
276
+ type ToSchemaOutput<RorO, I extends Input | Input['in']> = RorO extends TypedResponse<infer T, infer U, infer F> ? {
277
+ output: unknown extends T ? {} : T;
278
+ outputFormat: I extends {
279
+ outputFormat: string;
280
+ } ? I['outputFormat'] : F;
281
+ status: U;
282
+ } : {
283
+ output: unknown extends RorO ? {} : RorO;
284
+ outputFormat: unknown extends RorO ? 'json' : I extends {
285
+ outputFormat: string;
286
+ } ? I['outputFormat'] : 'json';
287
+ status: StatusCode;
288
+ };
289
+ 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>]: {
290
+ input: AddParam<ExtractInput<I>, P>;
291
+ output: {};
292
+ outputFormat: ResponseFormat;
293
+ status: StatusCode;
294
+ } } } : [RorO] extends [never] ? {} : [RorO] extends [Promise<void>] ? {} : { [K in P]: { [K2 in M as AddDollar<K2>]: Simplify<{
295
+ input: AddParam<ExtractInput<I>, P>;
296
+ } & ToSchemaOutput<RorO, I>> } };
297
+ type Schema = {
298
+ [Path: string]: {
299
+ [Method: `$${Lowercase<string>}`]: Endpoint;
300
+ };
301
+ };
302
+ 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>;
303
+ type Endpoint = {
304
+ input: any;
305
+ output: any;
306
+ outputFormat: ResponseFormat;
307
+ status: StatusCode;
308
+ };
309
+ 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;
310
+ type FlattenIfIntersect<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
311
+ 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 };
312
+ type MergeEndpointParamsWithPath<T extends Endpoint, SubPath extends string> = T extends unknown ? {
313
+ input: T['input'] extends {
314
+ param: infer _;
315
+ } ? ExtractParams<SubPath> extends never ? T['input'] : FlattenIfIntersect<T['input'] & {
316
+ param: { [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string };
317
+ }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T['input'] : T['input'] & {
318
+ param: { [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string };
319
+ };
320
+ output: T['output'];
321
+ outputFormat: T['outputFormat'];
322
+ status: T['status'];
323
+ } : never;
324
+ type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I extends {
325
+ param: infer _;
326
+ } ? I : I & {
327
+ param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
328
+ };
329
+ type AddDollar<T extends string> = `$${Lowercase<T>}`;
330
+ 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}`;
331
+ type KnownResponseFormat = 'json' | 'text' | 'redirect';
332
+ type ResponseFormat = KnownResponseFormat | string;
333
+ type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = (T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat)> = {
334
+ _data: T;
335
+ _status: U;
336
+ _format: F;
337
+ };
338
+ type MergeTypedResponse<T> = T extends Promise<void> ? T : T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;
339
+ type ExtractTypedResponseOnly<T> = T extends TypedResponse ? T : never;
340
+ 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;
341
+ type FormValue = string | Blob;
342
+ type ParsedFormValue = string | File;
343
+ type ValidationTargets<T extends FormValue = ParsedFormValue, P extends string = string> = {
344
+ json: any;
345
+ form: Record<string, T | T[]>;
346
+ query: Record<string, string | string[]>;
347
+ param: Record<P, P extends `${infer _}?` ? string | undefined : string>;
348
+ header: Record<RequestHeader | CustomHeader, string>;
349
+ cookie: Record<string, string>;
350
+ };
351
+ type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern : never;
352
+ type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
353
+ type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : { [K in T]: string };
354
+ type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends { [K in Target]: infer R } ? R : never;
355
+ type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
356
+ type ProcessHead<T> = IfAnyThenEmptyObject<T extends Env ? (Env extends T ? {} : T) : T>;
357
+ type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
358
+ declare abstract class FetchEventLike {
359
+ abstract readonly request: Request;
360
+ abstract respondWith(promise: Response | Promise<Response>): void;
361
+ abstract passThroughOnException(): void;
362
+ abstract waitUntil(promise: Promise<void>): void;
363
+ }
364
+ //#endregion
365
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/utils/body.d.ts
366
+ type BodyDataValueDot = {
367
+ [x: string]: string | File | BodyDataValueDot;
368
+ };
369
+ type BodyDataValueDotAll = {
370
+ [x: string]: string | File | (string | File)[] | BodyDataValueDotAll;
371
+ };
372
+ 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 } & {};
373
+ type BodyDataValueComponent<T> = string | File | (T extends {
374
+ all: false;
375
+ } ? never : T extends {
376
+ all: true;
377
+ } | {
378
+ all: boolean;
379
+ } ? (string | File)[] : never);
380
+ type BodyDataValueObject<T> = {
381
+ [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T>;
382
+ };
383
+ type BodyDataValue<T> = BodyDataValueComponent<T> | (T extends {
384
+ dot: false;
385
+ } ? never : T extends {
386
+ dot: true;
387
+ } | {
388
+ dot: boolean;
389
+ } ? BodyDataValueObject<T> : never);
390
+ type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<Record<string, BodyDataValue<T>>>;
391
+ type ParseBodyOptions = {
392
+ /**
393
+ * Determines whether all fields with multiple values should be parsed as arrays.
394
+ * @default false
395
+ * @example
396
+ * const data = new FormData()
397
+ * data.append('file', 'aaa')
398
+ * data.append('file', 'bbb')
399
+ * data.append('message', 'hello')
400
+ *
401
+ * If all is false:
402
+ * parseBody should return { file: 'bbb', message: 'hello' }
403
+ *
404
+ * If all is true:
405
+ * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
406
+ */
407
+ all: boolean;
408
+ /**
409
+ * Determines whether all fields with dot notation should be parsed as nested objects.
410
+ * @default false
411
+ * @example
412
+ * const data = new FormData()
413
+ * data.append('obj.key1', 'value1')
414
+ * data.append('obj.key2', 'value2')
415
+ *
416
+ * If dot is false:
417
+ * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
418
+ *
419
+ * If dot is true:
420
+ * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
421
+ */
422
+ dot: boolean;
423
+ };
424
+ //#endregion
425
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/request.d.ts
426
+ type Body = {
427
+ json: any;
428
+ text: string;
429
+ arrayBuffer: ArrayBuffer;
430
+ blob: Blob;
431
+ formData: FormData;
432
+ };
433
+ type BodyCache = Partial<Body>;
434
+ declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
435
+ /**
436
+ * `.raw` can get the raw Request object.
437
+ *
438
+ * @see {@link https://hono.dev/docs/api/request#raw}
439
+ *
440
+ * @example
441
+ * ```ts
442
+ * // For Cloudflare Workers
443
+ * app.post('/', async (c) => {
444
+ * const metadata = c.req.raw.cf?.hostMetadata?
445
+ * ...
446
+ * })
447
+ * ```
448
+ */
449
+ raw: Request;
450
+ routeIndex: number;
451
+ /**
452
+ * `.path` can get the pathname of the request.
453
+ *
454
+ * @see {@link https://hono.dev/docs/api/request#path}
455
+ *
456
+ * @example
457
+ * ```ts
458
+ * app.get('/about/me', (c) => {
459
+ * const pathname = c.req.path // `/about/me`
460
+ * })
461
+ * ```
462
+ */
463
+ path: string;
464
+ bodyCache: BodyCache;
465
+ constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
466
+ /**
467
+ * `.req.param()` gets the path parameters.
468
+ *
469
+ * @see {@link https://hono.dev/docs/api/routing#path-parameter}
470
+ *
471
+ * @example
472
+ * ```ts
473
+ * const name = c.req.param('name')
474
+ * // or all parameters at once
475
+ * const { id, comment_id } = c.req.param()
476
+ * ```
477
+ */
478
+ param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: string extends P ? never : P2 extends `${infer _}?` ? never : P2): string;
479
+ param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
480
+ param(key: string): string | undefined;
481
+ param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
482
+ /**
483
+ * `.query()` can get querystring parameters.
484
+ *
485
+ * @see {@link https://hono.dev/docs/api/request#query}
486
+ *
487
+ * @example
488
+ * ```ts
489
+ * // Query params
490
+ * app.get('/search', (c) => {
491
+ * const query = c.req.query('q')
492
+ * })
493
+ *
494
+ * // Get all params at once
495
+ * app.get('/search', (c) => {
496
+ * const { q, limit, offset } = c.req.query()
497
+ * })
498
+ * ```
499
+ */
500
+ query(key: string): string | undefined;
501
+ query(): Record<string, string>;
502
+ /**
503
+ * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
504
+ *
505
+ * @see {@link https://hono.dev/docs/api/request#queries}
506
+ *
507
+ * @example
508
+ * ```ts
509
+ * app.get('/search', (c) => {
510
+ * // tags will be string[]
511
+ * const tags = c.req.queries('tags')
512
+ * })
513
+ * ```
514
+ */
515
+ queries(key: string): string[] | undefined;
516
+ queries(): Record<string, string[]>;
517
+ /**
518
+ * `.header()` can get the request header value.
519
+ *
520
+ * @see {@link https://hono.dev/docs/api/request#header}
521
+ *
522
+ * @example
523
+ * ```ts
524
+ * app.get('/', (c) => {
525
+ * const userAgent = c.req.header('User-Agent')
526
+ * })
527
+ * ```
528
+ */
529
+ header(name: RequestHeader): string | undefined;
530
+ header(name: string): string | undefined;
531
+ header(): Record<RequestHeader | (string & CustomHeader), string>;
532
+ /**
533
+ * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
534
+ *
535
+ * @see {@link https://hono.dev/docs/api/request#parsebody}
536
+ *
537
+ * @example
538
+ * ```ts
539
+ * app.post('/entry', async (c) => {
540
+ * const body = await c.req.parseBody()
541
+ * })
542
+ * ```
543
+ */
544
+ parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
545
+ parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
546
+ /**
547
+ * `.json()` can parse Request body of type `application/json`
548
+ *
549
+ * @see {@link https://hono.dev/docs/api/request#json}
550
+ *
551
+ * @example
552
+ * ```ts
553
+ * app.post('/entry', async (c) => {
554
+ * const body = await c.req.json()
555
+ * })
556
+ * ```
557
+ */
558
+ json<T = any>(): Promise<T>;
559
+ /**
560
+ * `.text()` can parse Request body of type `text/plain`
561
+ *
562
+ * @see {@link https://hono.dev/docs/api/request#text}
563
+ *
564
+ * @example
565
+ * ```ts
566
+ * app.post('/entry', async (c) => {
567
+ * const body = await c.req.text()
568
+ * })
569
+ * ```
570
+ */
571
+ text(): Promise<string>;
572
+ /**
573
+ * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
574
+ *
575
+ * @see {@link https://hono.dev/docs/api/request#arraybuffer}
576
+ *
577
+ * @example
578
+ * ```ts
579
+ * app.post('/entry', async (c) => {
580
+ * const body = await c.req.arrayBuffer()
581
+ * })
582
+ * ```
583
+ */
584
+ arrayBuffer(): Promise<ArrayBuffer>;
585
+ /**
586
+ * `.bytes()` parses the request body as a `Uint8Array`.
587
+ *
588
+ * @see {@link https://hono.dev/docs/api/request#bytes}
589
+ *
590
+ * @example
591
+ * ```ts
592
+ * app.post('/entry', async (c) => {
593
+ * const body = await c.req.bytes()
594
+ * })
595
+ * ```
596
+ */
597
+ bytes(): Promise<Uint8Array>;
598
+ /**
599
+ * Parses the request body as a `Blob`.
600
+ * @example
601
+ * ```ts
602
+ * app.post('/entry', async (c) => {
603
+ * const body = await c.req.blob();
604
+ * });
605
+ * ```
606
+ * @see https://hono.dev/docs/api/request#blob
607
+ */
608
+ blob(): Promise<Blob>;
609
+ /**
610
+ * Parses the request body as `FormData`.
611
+ * @example
612
+ * ```ts
613
+ * app.post('/entry', async (c) => {
614
+ * const body = await c.req.formData();
615
+ * });
616
+ * ```
617
+ * @see https://hono.dev/docs/api/request#formdata
618
+ */
619
+ formData(): Promise<FormData>;
620
+ /**
621
+ * Adds validated data to the request.
622
+ *
623
+ * @param target - The target of the validation.
624
+ * @param data - The validated data to add.
625
+ */
626
+ addValidatedData(target: keyof ValidationTargets, data: {}): void;
627
+ /**
628
+ * Gets validated data from the request.
629
+ *
630
+ * @param target - The target of the validation.
631
+ * @returns The validated data.
632
+ *
633
+ * @see https://hono.dev/docs/api/request#valid
634
+ */
635
+ valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
636
+ /**
637
+ * `.url()` can get the request url strings.
638
+ *
639
+ * @see {@link https://hono.dev/docs/api/request#url}
640
+ *
641
+ * @example
642
+ * ```ts
643
+ * app.get('/about/me', (c) => {
644
+ * const url = c.req.url // `http://localhost:8787/about/me`
645
+ * ...
646
+ * })
647
+ * ```
648
+ */
649
+ get url(): string;
650
+ /**
651
+ * `.method()` can get the method name of the request.
652
+ *
653
+ * @see {@link https://hono.dev/docs/api/request#method}
654
+ *
655
+ * @example
656
+ * ```ts
657
+ * app.get('/about/me', (c) => {
658
+ * const method = c.req.method // `GET`
659
+ * })
660
+ * ```
661
+ */
662
+ get method(): string;
663
+ get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
664
+ /**
665
+ * `.matchedRoutes()` can return a matched route in the handler
666
+ *
667
+ * @deprecated
668
+ *
669
+ * Use matchedRoutes helper defined in "hono/route" instead.
670
+ *
671
+ * @see {@link https://hono.dev/docs/api/request#matchedroutes}
672
+ *
673
+ * @example
674
+ * ```ts
675
+ * app.use('*', async function logger(c, next) {
676
+ * await next()
677
+ * c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
678
+ * const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
679
+ * console.log(
680
+ * method,
681
+ * ' ',
682
+ * path,
683
+ * ' '.repeat(Math.max(10 - path.length, 0)),
684
+ * name,
685
+ * i === c.req.routeIndex ? '<- respond from here' : ''
686
+ * )
687
+ * })
688
+ * })
689
+ * ```
690
+ */
691
+ get matchedRoutes(): RouterRoute[];
692
+ /**
693
+ * `routePath()` can retrieve the path registered within the handler
694
+ *
695
+ * @deprecated
696
+ *
697
+ * Use routePath helper defined in "hono/route" instead.
698
+ *
699
+ * @see {@link https://hono.dev/docs/api/request#routepath}
700
+ *
701
+ * @example
702
+ * ```ts
703
+ * app.get('/posts/:id', (c) => {
704
+ * return c.json({ path: c.req.routePath })
705
+ * })
706
+ * ```
707
+ */
708
+ get routePath(): string;
709
+ }
710
+ //#endregion
711
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/utils/mime.d.ts
712
+ /**
713
+ * Union types for BaseMime
714
+ */
715
+ type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
716
+ declare const _baseMimes: {
717
+ readonly aac: "audio/aac";
718
+ readonly avi: "video/x-msvideo";
719
+ readonly avif: "image/avif";
720
+ readonly av1: "video/av1";
721
+ readonly bin: "application/octet-stream";
722
+ readonly bmp: "image/bmp";
723
+ readonly css: "text/css; charset=utf-8";
724
+ readonly csv: "text/csv; charset=utf-8";
725
+ readonly eot: "application/vnd.ms-fontobject";
726
+ readonly epub: "application/epub+zip";
727
+ readonly gif: "image/gif";
728
+ readonly gz: "application/gzip";
729
+ readonly htm: "text/html; charset=utf-8";
730
+ readonly html: "text/html; charset=utf-8";
731
+ readonly ico: "image/x-icon";
732
+ readonly ics: "text/calendar; charset=utf-8";
733
+ readonly jpeg: "image/jpeg";
734
+ readonly jpg: "image/jpeg";
735
+ readonly js: "text/javascript; charset=utf-8";
736
+ readonly json: "application/json";
737
+ readonly jsonld: "application/ld+json";
738
+ readonly map: "application/json";
739
+ readonly mid: "audio/x-midi";
740
+ readonly midi: "audio/x-midi";
741
+ readonly mjs: "text/javascript; charset=utf-8";
742
+ readonly mp3: "audio/mpeg";
743
+ readonly mp4: "video/mp4";
744
+ readonly mpeg: "video/mpeg";
745
+ readonly oga: "audio/ogg";
746
+ readonly ogv: "video/ogg";
747
+ readonly ogx: "application/ogg";
748
+ readonly opus: "audio/opus";
749
+ readonly otf: "font/otf";
750
+ readonly pdf: "application/pdf";
751
+ readonly png: "image/png";
752
+ readonly rtf: "application/rtf";
753
+ readonly svg: "image/svg+xml; charset=utf-8";
754
+ readonly tif: "image/tiff";
755
+ readonly tiff: "image/tiff";
756
+ readonly ts: "video/mp2t";
757
+ readonly ttf: "font/ttf";
758
+ readonly txt: "text/plain; charset=utf-8";
759
+ readonly wasm: "application/wasm";
760
+ readonly webm: "video/webm";
761
+ readonly weba: "audio/webm";
762
+ readonly webmanifest: "application/manifest+json";
763
+ readonly webp: "image/webp";
764
+ readonly woff: "font/woff";
765
+ readonly woff2: "font/woff2";
766
+ readonly xhtml: "application/xhtml+xml; charset=utf-8";
767
+ readonly xml: "application/xml; charset=utf-8";
768
+ readonly zip: "application/zip";
769
+ readonly '3gp': "video/3gpp";
770
+ readonly '3g2': "video/3gpp2";
771
+ readonly gltf: "model/gltf+json";
772
+ readonly glb: "model/gltf-binary";
773
+ };
774
+ //#endregion
775
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/context.d.ts
776
+ type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
777
+ /**
778
+ * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
779
+ */
780
+ type Data = string | ArrayBuffer | ReadableStream | Uint8Array<ArrayBuffer>;
781
+ /**
782
+ * Interface for the execution context in a web worker or similar environment.
783
+ */
784
+ interface ExecutionContext {
785
+ /**
786
+ * Extends the lifetime of the event callback until the promise is settled.
787
+ *
788
+ * @param promise - A promise to wait for.
789
+ */
790
+ waitUntil(promise: Promise<unknown>): void;
791
+ /**
792
+ * Allows the event to be passed through to subsequent event listeners.
793
+ */
794
+ passThroughOnException(): void;
795
+ /**
796
+ * For compatibility with Wrangler 4.x.
797
+ */
798
+ props: any;
799
+ /**
800
+ * For compatibility with Wrangler 4.x.
801
+ */
802
+ exports?: any;
803
+ }
804
+ /**
805
+ * Interface for context variable mapping.
806
+ */
807
+ interface ContextVariableMap {}
808
+ /**
809
+ * Interface for context renderer.
810
+ */
811
+ interface ContextRenderer {}
812
+ /**
813
+ * Interface representing a renderer for content.
814
+ *
815
+ * @interface DefaultRenderer
816
+ * @param {string | Promise<string>} content - The content to be rendered, which can be either a string or a Promise resolving to a string.
817
+ * @returns {Response | Promise<Response>} - The response after rendering the content, which can be either a Response or a Promise resolving to a Response.
818
+ */
819
+ interface DefaultRenderer {
820
+ (content: string | Promise<string>): Response | Promise<Response>;
821
+ }
822
+ /**
823
+ * Renderer type which can either be a ContextRenderer or DefaultRenderer.
824
+ */
825
+ type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
826
+ /**
827
+ * Extracts the props for the renderer.
828
+ */
829
+ type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
830
+ type Layout<T = Record<string, any>> = (props: T) => any;
831
+ /**
832
+ * Interface for getting context variables.
833
+ *
834
+ * @template E - Environment type.
835
+ */
836
+ interface Get<E extends Env> {
837
+ <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
838
+ <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
839
+ }
840
+ /**
841
+ * Interface for setting context variables.
842
+ *
843
+ * @template E - Environment type.
844
+ */
845
+ interface Set$1<E extends Env> {
846
+ <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
847
+ <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
848
+ }
849
+ /**
850
+ * Interface for creating a new response.
851
+ */
852
+ interface NewResponse {
853
+ (data: Data | null, status?: StatusCode, headers?: HeaderRecord): Response;
854
+ (data: Data | null, init?: ResponseOrInit): Response;
855
+ }
856
+ /**
857
+ * Interface for responding with a body.
858
+ */
859
+ interface BodyRespond {
860
+ <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'body'>;
861
+ <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'body'>;
862
+ <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
863
+ <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
864
+ }
865
+ /**
866
+ * Interface for responding with text.
867
+ *
868
+ * @interface TextRespond
869
+ * @template T - The type of the text content.
870
+ * @template U - The type of the status code.
871
+ *
872
+ * @param {T} text - The text content to be included in the response.
873
+ * @param {U} [status] - An optional status code for the response.
874
+ * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
875
+ *
876
+ * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
877
+ */
878
+ interface TextRespond {
879
+ <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
880
+ <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
881
+ }
882
+ /**
883
+ * Interface for responding with JSON.
884
+ *
885
+ * @interface JSONRespond
886
+ * @template T - The type of the JSON value or simplified unknown type.
887
+ * @template U - The type of the status code.
888
+ *
889
+ * @param {T} object - The JSON object to be included in the response.
890
+ * @param {U} [status] - An optional status code for the response.
891
+ * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
892
+ *
893
+ * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
894
+ */
895
+ interface JSONRespond {
896
+ <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
897
+ <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
898
+ }
899
+ /**
900
+ * @template T - The type of the JSON value or simplified unknown type.
901
+ * @template U - The type of the status code.
902
+ *
903
+ * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
904
+ */
905
+ type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
906
+ /**
907
+ * Interface representing a function that responds with HTML content.
908
+ *
909
+ * @param html - The HTML content to respond with, which can be a string or a Promise that resolves to a string.
910
+ * @param status - (Optional) The HTTP status code for the response.
911
+ * @param headers - (Optional) A record of headers to include in the response.
912
+ * @param init - (Optional) The response initialization object.
913
+ *
914
+ * @returns A Response object or a Promise that resolves to a Response object.
915
+ */
916
+ interface HTMLRespond {
917
+ <T extends string | Promise<string>>(html: T, status?: ContentfulStatusCode, headers?: HeaderRecord): T extends string ? Response : Promise<Response>;
918
+ <T extends string | Promise<string>>(html: T, init?: ResponseOrInit<ContentfulStatusCode>): T extends string ? Response : Promise<Response>;
919
+ }
920
+ /**
921
+ * Options for configuring the context.
922
+ *
923
+ * @template E - Environment type.
924
+ */
925
+ type ContextOptions<E extends Env> = {
926
+ /**
927
+ * Bindings for the environment.
928
+ */
929
+ env: E['Bindings'];
930
+ /**
931
+ * Execution context for the request.
932
+ */
933
+ executionCtx?: FetchEventLike | ExecutionContext | undefined;
934
+ /**
935
+ * Handler for not found responses.
936
+ */
937
+ notFoundHandler?: NotFoundHandler<E>;
938
+ matchResult?: Result<[H, RouterRoute]>;
939
+ path?: string;
940
+ };
941
+ interface SetHeadersOptions {
942
+ append?: boolean;
943
+ }
944
+ interface SetHeaders {
945
+ (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
946
+ (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
947
+ (name: string, value?: string, options?: SetHeadersOptions): void;
948
+ }
949
+ type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
950
+ interface ResponseInit<T extends StatusCode = StatusCode> {
951
+ headers?: ResponseHeadersInit;
952
+ status?: T;
953
+ statusText?: string;
954
+ }
955
+ type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response;
956
+ declare class Context<E extends Env = any, P extends string = any, I extends Input = {}> {
957
+ /**
958
+ * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
959
+ *
960
+ * @see {@link https://hono.dev/docs/api/context#env}
961
+ *
962
+ * @example
963
+ * ```ts
964
+ * // Environment object for Cloudflare Workers
965
+ * app.get('*', async c => {
966
+ * const counter = c.env.COUNTER
967
+ * })
968
+ * ```
969
+ */
970
+ env: E['Bindings'];
971
+ finalized: boolean;
972
+ /**
973
+ * `.error` can get the error object from the middleware if the Handler throws an error.
974
+ *
975
+ * @see {@link https://hono.dev/docs/api/context#error}
976
+ *
977
+ * @example
978
+ * ```ts
979
+ * app.use('*', async (c, next) => {
980
+ * await next()
981
+ * if (c.error) {
982
+ * // do something...
983
+ * }
984
+ * })
985
+ * ```
986
+ */
987
+ error: Error | undefined;
988
+ /**
989
+ * Creates an instance of the Context class.
990
+ *
991
+ * @param req - The Request object.
992
+ * @param options - Optional configuration options for the context.
993
+ */
994
+ constructor(req: Request, options?: ContextOptions<E>);
995
+ /**
996
+ * `.req` is the instance of {@link HonoRequest}.
997
+ */
998
+ get req(): HonoRequest<P, I['out']>;
999
+ /**
1000
+ * @see {@link https://hono.dev/docs/api/context#event}
1001
+ * The FetchEvent associated with the current request.
1002
+ *
1003
+ * @throws Will throw an error if the context does not have a FetchEvent.
1004
+ */
1005
+ get event(): FetchEventLike;
1006
+ /**
1007
+ * @see {@link https://hono.dev/docs/api/context#executionctx}
1008
+ * The ExecutionContext associated with the current request.
1009
+ *
1010
+ * @throws Will throw an error if the context does not have an ExecutionContext.
1011
+ */
1012
+ get executionCtx(): ExecutionContext;
1013
+ /**
1014
+ * @see {@link https://hono.dev/docs/api/context#res}
1015
+ * The Response object for the current request.
1016
+ */
1017
+ get res(): Response;
1018
+ /**
1019
+ * Sets the Response object for the current request.
1020
+ *
1021
+ * @param _res - The Response object to set.
1022
+ */
1023
+ set res(_res: Response | undefined);
1024
+ /**
1025
+ * `.render()` can create a response within a layout.
1026
+ *
1027
+ * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
1028
+ *
1029
+ * @example
1030
+ * ```ts
1031
+ * app.get('/', (c) => {
1032
+ * return c.render('Hello!')
1033
+ * })
1034
+ * ```
1035
+ */
1036
+ render: Renderer;
1037
+ /**
1038
+ * Sets the layout for the response.
1039
+ *
1040
+ * @param layout - The layout to set.
1041
+ * @returns The layout function.
1042
+ */
1043
+ setLayout: (layout: Layout<PropsForRenderer & {
1044
+ Layout: Layout;
1045
+ }>) => Layout<PropsForRenderer & {
1046
+ Layout: Layout;
1047
+ }>;
1048
+ /**
1049
+ * Gets the current layout for the response.
1050
+ *
1051
+ * @returns The current layout function.
1052
+ */
1053
+ getLayout: () => Layout<PropsForRenderer & {
1054
+ Layout: Layout;
1055
+ }> | undefined;
1056
+ /**
1057
+ * `.setRenderer()` can set the layout in the custom middleware.
1058
+ *
1059
+ * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
1060
+ *
1061
+ * @example
1062
+ * ```tsx
1063
+ * app.use('*', async (c, next) => {
1064
+ * c.setRenderer((content) => {
1065
+ * return c.html(
1066
+ * <html>
1067
+ * <body>
1068
+ * <p>{content}</p>
1069
+ * </body>
1070
+ * </html>
1071
+ * )
1072
+ * })
1073
+ * await next()
1074
+ * })
1075
+ * ```
1076
+ */
1077
+ setRenderer: (renderer: Renderer) => void;
1078
+ /**
1079
+ * `.header()` can set headers.
1080
+ *
1081
+ * @see {@link https://hono.dev/docs/api/context#header}
1082
+ *
1083
+ * @example
1084
+ * ```ts
1085
+ * app.get('/welcome', (c) => {
1086
+ * // Set headers
1087
+ * c.header('X-Message', 'Hello!')
1088
+ * c.header('Content-Type', 'text/plain')
1089
+ *
1090
+ * return c.body('Thank you for coming')
1091
+ * })
1092
+ * ```
1093
+ */
1094
+ header: SetHeaders;
1095
+ status: (status: StatusCode) => void;
1096
+ /**
1097
+ * `.set()` can set the value specified by the key.
1098
+ *
1099
+ * @see {@link https://hono.dev/docs/api/context#set-get}
1100
+ *
1101
+ * @example
1102
+ * ```ts
1103
+ * app.use('*', async (c, next) => {
1104
+ * c.set('message', 'Hono is hot!!')
1105
+ * await next()
1106
+ * })
1107
+ * ```
1108
+ */
1109
+ set: Set$1<IsAny<E> extends true ? {
1110
+ Variables: ContextVariableMap & Record<string, any>;
1111
+ } : E>;
1112
+ /**
1113
+ * `.get()` can use the value specified by the key.
1114
+ *
1115
+ * @see {@link https://hono.dev/docs/api/context#set-get}
1116
+ *
1117
+ * @example
1118
+ * ```ts
1119
+ * app.get('/', (c) => {
1120
+ * const message = c.get('message')
1121
+ * return c.text(`The message is "${message}"`)
1122
+ * })
1123
+ * ```
1124
+ */
1125
+ get: Get<IsAny<E> extends true ? {
1126
+ Variables: ContextVariableMap & Record<string, any>;
1127
+ } : E>;
1128
+ /**
1129
+ * `.var` can access the value of a variable.
1130
+ *
1131
+ * @see {@link https://hono.dev/docs/api/context#var}
1132
+ *
1133
+ * @example
1134
+ * ```ts
1135
+ * const result = c.var.client.oneMethod()
1136
+ * ```
1137
+ */
1138
+ get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
1139
+ newResponse: NewResponse;
1140
+ /**
1141
+ * `.body()` can return the HTTP response.
1142
+ * You can set headers with `.header()` and set HTTP status code with `.status`.
1143
+ * This can also be set in `.text()`, `.json()` and so on.
1144
+ *
1145
+ * @see {@link https://hono.dev/docs/api/context#body}
1146
+ *
1147
+ * @example
1148
+ * ```ts
1149
+ * app.get('/welcome', (c) => {
1150
+ * // Set headers
1151
+ * c.header('X-Message', 'Hello!')
1152
+ * c.header('Content-Type', 'text/plain')
1153
+ * // Set HTTP status code
1154
+ * c.status(201)
1155
+ *
1156
+ * // Return the response body
1157
+ * return c.body('Thank you for coming')
1158
+ * })
1159
+ * ```
1160
+ */
1161
+ body: BodyRespond;
1162
+ /**
1163
+ * `.text()` can render text as `Content-Type:text/plain`.
1164
+ *
1165
+ * @see {@link https://hono.dev/docs/api/context#text}
1166
+ *
1167
+ * @example
1168
+ * ```ts
1169
+ * app.get('/say', (c) => {
1170
+ * return c.text('Hello!')
1171
+ * })
1172
+ * ```
1173
+ */
1174
+ text: TextRespond;
1175
+ /**
1176
+ * `.json()` can render JSON as `Content-Type:application/json`.
1177
+ *
1178
+ * @see {@link https://hono.dev/docs/api/context#json}
1179
+ *
1180
+ * @example
1181
+ * ```ts
1182
+ * app.get('/api', (c) => {
1183
+ * return c.json({ message: 'Hello!' })
1184
+ * })
1185
+ * ```
1186
+ */
1187
+ json: JSONRespond;
1188
+ html: HTMLRespond;
1189
+ /**
1190
+ * `.redirect()` can Redirect, default status code is 302.
1191
+ *
1192
+ * @see {@link https://hono.dev/docs/api/context#redirect}
1193
+ *
1194
+ * @example
1195
+ * ```ts
1196
+ * app.get('/redirect', (c) => {
1197
+ * return c.redirect('/')
1198
+ * })
1199
+ * app.get('/redirect-permanently', (c) => {
1200
+ * return c.redirect('/', 301)
1201
+ * })
1202
+ * ```
1203
+ */
1204
+ redirect: <T extends RedirectStatusCode = 302>(location: string | URL, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
1205
+ /**
1206
+ * `.notFound()` can return the Not Found Response.
1207
+ *
1208
+ * @see {@link https://hono.dev/docs/api/context#notfound}
1209
+ *
1210
+ * @example
1211
+ * ```ts
1212
+ * app.get('/notfound', (c) => {
1213
+ * return c.notFound()
1214
+ * })
1215
+ * ```
1216
+ */
1217
+ notFound: () => ReturnType<NotFoundHandler>;
1218
+ }
1219
+ //#endregion
1220
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/hono-base.d.ts
1221
+ type GetPath<E extends Env> = (request: Request, options?: {
1222
+ env?: E['Bindings'];
1223
+ }) => string;
1224
+ type HonoOptions<E extends Env> = {
1225
+ /**
1226
+ * `strict` option specifies whether to distinguish whether the last path is a directory or not.
1227
+ *
1228
+ * @see {@link https://hono.dev/docs/api/hono#strict-mode}
1229
+ *
1230
+ * @default true
1231
+ */
1232
+ strict?: boolean;
1233
+ /**
1234
+ * `router` option specifies which router to use.
1235
+ *
1236
+ * @see {@link https://hono.dev/docs/api/hono#router-option}
1237
+ *
1238
+ * @example
1239
+ * ```ts
1240
+ * const app = new Hono({ router: new RegExpRouter() })
1241
+ * ```
1242
+ */
1243
+ router?: Router<[H, RouterRoute]>;
1244
+ /**
1245
+ * `getPath` can handle the host header value.
1246
+ *
1247
+ * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
1248
+ *
1249
+ * @example
1250
+ * ```ts
1251
+ * const app = new Hono({
1252
+ * getPath: (req) =>
1253
+ * '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
1254
+ * })
1255
+ *
1256
+ * app.get('/www1.example.com/hello', () => c.text('hello www1'))
1257
+ *
1258
+ * // A following request will match the route:
1259
+ * // new Request('http://www1.example.com/hello', {
1260
+ * // headers: { host: 'www1.example.com' },
1261
+ * // })
1262
+ * ```
1263
+ */
1264
+ getPath?: GetPath<E>;
1265
+ };
1266
+ type MountOptionHandler = (c: Context) => unknown;
1267
+ type MountReplaceRequest = (originalRequest: Request) => Request;
1268
+ type MountOptions = MountOptionHandler | {
1269
+ optionHandler?: MountOptionHandler;
1270
+ replaceRequest?: MountReplaceRequest | false;
1271
+ };
1272
+ declare class Hono$1<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
1273
+ get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
1274
+ post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
1275
+ put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
1276
+ delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
1277
+ options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
1278
+ patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
1279
+ all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
1280
+ on: OnHandlerInterface<E, S, BasePath>;
1281
+ use: MiddlewareHandlerInterface<E, S, BasePath>;
1282
+ router: Router<[H, RouterRoute]>;
1283
+ readonly getPath: GetPath<E>;
1284
+ private _basePath;
1285
+ routes: RouterRoute[];
1286
+ constructor(options?: HonoOptions<E>);
1287
+ private errorHandler;
1288
+ /**
1289
+ * `.route()` allows grouping other Hono instance in routes.
1290
+ *
1291
+ * @see {@link https://hono.dev/docs/api/routing#grouping}
1292
+ *
1293
+ * @param {string} path - base Path
1294
+ * @param {Hono} app - other Hono instance
1295
+ * @returns {Hono} routed Hono instance
1296
+ *
1297
+ * @example
1298
+ * ```ts
1299
+ * const app = new Hono()
1300
+ * const app2 = new Hono()
1301
+ *
1302
+ * app2.get("/user", (c) => c.text("user"))
1303
+ * app.route("/api", app2) // GET /api/user
1304
+ * ```
1305
+ */
1306
+ 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>;
1307
+ /**
1308
+ * `.basePath()` allows base paths to be specified.
1309
+ *
1310
+ * @see {@link https://hono.dev/docs/api/routing#base-path}
1311
+ *
1312
+ * @param {string} path - base Path
1313
+ * @returns {Hono} changed Hono instance
1314
+ *
1315
+ * @example
1316
+ * ```ts
1317
+ * const api = new Hono().basePath('/api')
1318
+ * ```
1319
+ */
1320
+ basePath<SubPath extends string>(path: SubPath): Hono$1<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
1321
+ /**
1322
+ * `.onError()` handles an error and returns a customized Response.
1323
+ *
1324
+ * @see {@link https://hono.dev/docs/api/hono#error-handling}
1325
+ *
1326
+ * @param {ErrorHandler} handler - request Handler for error
1327
+ * @returns {Hono} changed Hono instance
1328
+ *
1329
+ * @example
1330
+ * ```ts
1331
+ * app.onError((err, c) => {
1332
+ * console.error(`${err}`)
1333
+ * return c.text('Custom Error Message', 500)
1334
+ * })
1335
+ * ```
1336
+ */
1337
+ onError: (handler: ErrorHandler<E>) => Hono$1<E, S, BasePath, CurrentPath>;
1338
+ /**
1339
+ * `.notFound()` allows you to customize a Not Found Response.
1340
+ *
1341
+ * @see {@link https://hono.dev/docs/api/hono#not-found}
1342
+ *
1343
+ * @param {NotFoundHandler} handler - request handler for not-found
1344
+ * @returns {Hono} changed Hono instance
1345
+ *
1346
+ * @example
1347
+ * ```ts
1348
+ * app.notFound((c) => {
1349
+ * return c.text('Custom 404 Message', 404)
1350
+ * })
1351
+ * ```
1352
+ */
1353
+ notFound: (handler: NotFoundHandler<E>) => Hono$1<E, S, BasePath, CurrentPath>;
1354
+ /**
1355
+ * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
1356
+ *
1357
+ * @see {@link https://hono.dev/docs/api/hono#mount}
1358
+ *
1359
+ * @param {string} path - base Path
1360
+ * @param {Function} applicationHandler - other Request Handler
1361
+ * @param {MountOptions} [options] - options of `.mount()`
1362
+ * @returns {Hono} mounted Hono instance
1363
+ *
1364
+ * @example
1365
+ * ```ts
1366
+ * import { Router as IttyRouter } from 'itty-router'
1367
+ * import { Hono } from 'hono'
1368
+ * // Create itty-router application
1369
+ * const ittyRouter = IttyRouter()
1370
+ * // GET /itty-router/hello
1371
+ * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
1372
+ *
1373
+ * const app = new Hono()
1374
+ * app.mount('/itty-router', ittyRouter.handle)
1375
+ * ```
1376
+ *
1377
+ * @example
1378
+ * ```ts
1379
+ * const app = new Hono()
1380
+ * // Send the request to another application without modification.
1381
+ * app.mount('/app', anotherApp, {
1382
+ * replaceRequest: (req) => req,
1383
+ * })
1384
+ * ```
1385
+ */
1386
+ mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono$1<E, S, BasePath, CurrentPath>;
1387
+ /**
1388
+ * `.fetch()` will be entry point of your app.
1389
+ *
1390
+ * @see {@link https://hono.dev/docs/api/hono#fetch}
1391
+ *
1392
+ * @param {Request} request - request Object of request
1393
+ * @param {Env} Env - env Object
1394
+ * @param {ExecutionContext} - context of execution
1395
+ * @returns {Response | Promise<Response>} response of request
1396
+ *
1397
+ */
1398
+ fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1399
+ /**
1400
+ * `.request()` is a useful method for testing.
1401
+ * You can pass a URL or pathname to send a GET request.
1402
+ * app will return a Response object.
1403
+ * ```ts
1404
+ * test('GET /hello is ok', async () => {
1405
+ * const res = await app.request('/hello')
1406
+ * expect(res.status).toBe(200)
1407
+ * })
1408
+ * ```
1409
+ * @see https://hono.dev/docs/api/hono#request
1410
+ */
1411
+ request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1412
+ /**
1413
+ * `.fire()` automatically adds a global fetch event listener.
1414
+ * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
1415
+ * @deprecated
1416
+ * Use `fire` from `hono/service-worker` instead.
1417
+ * ```ts
1418
+ * import { Hono } from 'hono'
1419
+ * import { fire } from 'hono/service-worker'
1420
+ *
1421
+ * const app = new Hono()
1422
+ * // ...
1423
+ * fire(app)
1424
+ * ```
1425
+ * @see https://hono.dev/docs/api/hono#fire
1426
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
1427
+ * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
1428
+ */
1429
+ fire: () => void;
1430
+ }
1431
+ //#endregion
1432
+ //#region node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/types/preset/tiny.d.ts
1433
+ declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Hono$1<E, S, BasePath> {
1434
+ constructor(options?: HonoOptions<E>);
1435
+ }
1436
+ //#endregion
1437
+ //#region packages/server/src/contract.d.ts
1438
+ /**
1439
+ * Wire envelope for every error response. Mirrors `BaerlyError` so
1440
+ * the client SDK reconstructs the same class shape it would see
1441
+ * in-process. `code` is the discriminant; `cause` is never sent on
1442
+ * the wire.
1443
+ */
1444
+ interface HttpErrorEnvelope {
1445
+ readonly error: {
1446
+ readonly code: BaerlyErrorCode;
1447
+ readonly message: string;
1448
+ /**
1449
+ * Field-path issues, present only when `code === "SchemaError"`.
1450
+ * Each entry is `{ path, message }` where `path` is the dotted
1451
+ * key list from the validator. Older clients see this field as
1452
+ * `unknown` and ignore it; new clients destructure it for form-
1453
+ * side rendering.
1454
+ */
1455
+ readonly issues?: ReadonlyArray<{
1456
+ readonly path: ReadonlyArray<string | number>;
1457
+ readonly message: string;
1458
+ }>;
1459
+ };
1460
+ }
1461
+ /**
1462
+ * Long-poll response. `events` is the slice of `LogEntry`s between
1463
+ * the request's `cursor` and `next_cursor`. Client passes
1464
+ * `next_cursor` back on the next call. Empty `events` + same
1465
+ * `next_cursor` means "nothing changed within the budget"
1466
+ * (default budget: ~25s).
1467
+ */
1468
+ interface SinceResponse {
1469
+ readonly events: ReadonlyArray<LogEntry>;
1470
+ readonly next_cursor: string;
1471
+ }
1472
+ /**
1473
+ * Status-code policy. Listed here so the client SDK and the
1474
+ * conformance suite share one source of truth.
1475
+ *
1476
+ * | Status | Meaning |
1477
+ * |--------|------------------------------------------------------------------|
1478
+ * | 200 | `GET` read → `HttpOkEnvelope<T>`. `GET /v1/since` → `SinceResponse`. `PATCH` → `{ modified: number }`. |
1479
+ * | 201 | `POST` insert success — body `{ _id }`. |
1480
+ * | 204 | `DELETE` success — no body. |
1481
+ * | 304 | Reserved. Long-poll idleness ships as 200 + empty events. |
1482
+ * | 400 | Body parse failed → `HttpErrorEnvelope` `code:"SchemaError"`. |
1483
+ * | 401 | `Verifier` returned null → `code:"Unauthorized"`, `message: "Missing or invalid Authorization header"`. |
1484
+ * | 403 | Auth ok but tenant prefix denied → `code:"AccessDenied"`. |
1485
+ * | 404 | Doc not found → `code:"NotFound"`. NOT used for "tenant unknown" (→ 401). |
1486
+ * | 409 | CAS lost → `code:"Conflict"`. |
1487
+ * | 413 | Request body exceeded `MAX_BODY_BYTES` → `code:"PayloadTooLarge"`. |
1488
+ * | 500 | Anything else → `code:"Internal"`. |
1489
+ */
1490
+ type HttpStatus = 200 | 201 | 204 | 304 | 400 | 401 | 403 | 404 | 409 | 413 | 500;
1491
+ //#endregion
1492
+ //#region packages/server/src/http/router.d.ts
1493
+ /**
1494
+ * Options for {@link createRouter}.
1495
+ *
1496
+ * - `db` — single-tenant `Db` instance. The CF/Node adapters build a
1497
+ * fresh `Db` per request (after the Verifier resolves the tenant)
1498
+ * and hand it to a freshly-constructed router. The router itself
1499
+ * is stateless and per-request — `app.fetch(req)` is the only
1500
+ * entry point. The Verifier runs in the adapter (see `worker.ts` /
1501
+ * `server.ts`) before `createRouter` is called; the router itself
1502
+ * has no auth seam.
1503
+ */
1504
+ interface CreateRouterOptions {
1505
+ readonly db: Db<BaerlyConfig>;
1506
+ /** Override the long-poll budget. Forwarded to `longPollSince`. */
1507
+ readonly sinceTimeoutMs?: number;
1508
+ /** Override the long-poll inner-poll cadence. Forwarded to `longPollSince`. */
1509
+ readonly sincePollIntervalMs?: number;
1510
+ }
1511
+ /**
1512
+ * Build a Hono `app` that serves the CRUD routes:
1513
+ *
1514
+ * - `GET /v1/c/:collection/:id` → read one document.
1515
+ * - `GET /v1/c/:collection?where=<json>&order=<json>&limit=<n>` → list rows
1516
+ * matching a predicate, optionally ordered and capped.
1517
+ * - `POST /v1/c/:collection` → insert. Body: `{ doc }`. → `201 { _id }`.
1518
+ * - `PATCH /v1/c/:collection/:id` → merge-patch. Body: `{ patch }`. → `200 { modified }`.
1519
+ * - `PUT /v1/c/:collection/:id` → whole-doc replace. Body: `{ doc }`. → `200 { modified }`.
1520
+ * - `DELETE /v1/c/:collection/:id` → delete row by id. → `204`.
1521
+ * - `GET /v1/count?collection=<name>&where=<json>` → scalar `{ count: N }`.
1522
+ * - `GET /v1/since?collection=<name>&cursor=<opaque>` → long-poll log.
1523
+ *
1524
+ * @example
1525
+ * ```ts
1526
+ * import { createRouter, Db } from "@gusto/baerly-storage";
1527
+ * import { MemoryStorage } from "@gusto/baerly-storage";
1528
+ *
1529
+ * const db = Db.create({ storage: new MemoryStorage(), app: "tickets", tenant: "acme" });
1530
+ * const app = createRouter({ db });
1531
+ * // CF Workers:
1532
+ * export default { async fetch(req: Request) { return app.fetch(req); } };
1533
+ * ```
1534
+ */
1535
+ declare function createRouter(options: CreateRouterOptions): Hono;
1536
+ /**
1537
+ * Hard cap on request-body bytes. 1 MiB — matches `S3HttpStorage`'s
1538
+ * conformance-suite default. Over-cap → `413 PayloadTooLarge`.
1539
+ *
1540
+ * The Node adapter (`@baerly/adapter-node`) imports this constant
1541
+ * and passes it to `applyBodyCap`, which wraps the request body
1542
+ * with a counting `TransformStream` so chunked uploads trip the cap
1543
+ * mid-stream rather than materialising the full buffer. The
1544
+ * router's `readJsonBody` keeps the cap as a defence-in-depth check
1545
+ * (Content-Length pre-read + post-`arrayBuffer` length) for adapters
1546
+ * whose platform doesn't pre-cap.
1547
+ *
1548
+ * @internal — exported for tests and for the Node adapter's
1549
+ * `applyBodyCap` helper. Promote to
1550
+ * `packages/protocol/src/constants.ts` only on a third cross-
1551
+ * package consumer.
1552
+ */
1553
+ declare const MAX_BODY_BYTES: number;
1554
+ /**
1555
+ * Map an unknown thrown value onto the wire envelope plus an HTTP
1556
+ * status code. The mapping is keyed by `BaerlyError.code` so any future
1557
+ * code addition forces a re-check here (currently unmapped codes fall
1558
+ * through to 500 by design — see the `NetworkError` / `InvalidResponse`
1559
+ * / `Internal` comment in `ERROR_TO_STATUS`).
1560
+ *
1561
+ * @internal — exported for tests and for the `/v1/since` long-poll
1562
+ * handler in `./since.ts`. The `HttpErrorEnvelope` shape is locked;
1563
+ * do not mutate it.
1564
+ */
1565
+ declare function mapError(err: unknown): {
1566
+ status: HttpStatus;
1567
+ envelope: HttpErrorEnvelope;
1568
+ };
1569
+ //#endregion
1570
+ //#region packages/server/src/http/since.d.ts
1571
+ interface LongPollSinceOptions {
1572
+ readonly db: Db<BaerlyConfig>;
1573
+ readonly collection: string;
1574
+ /** Opaque cursor; empty string = from `log_seq_start`. */
1575
+ readonly cursor: string;
1576
+ readonly signal?: AbortSignal;
1577
+ readonly timeoutMs?: number;
1578
+ readonly pollIntervalMs?: number;
1579
+ }
1580
+ interface ListEventsSinceOptions {
1581
+ readonly db: Db<BaerlyConfig>;
1582
+ readonly collection: string;
1583
+ /** Opaque cursor; empty string = from `log_seq_start`. */
1584
+ readonly cursor: string;
1585
+ readonly signal?: AbortSignal;
1586
+ }
1587
+ /**
1588
+ * Long-poll wrapper around {@link listEventsSince}. Returns as soon
1589
+ * as the first non-empty poll lands, or when the wall-clock timeout
1590
+ * elapses (whichever comes first). On timeout the response is
1591
+ * `{ events: [], next_cursor: <same> }` — shipped as `200`, not `304`,
1592
+ * because the response body carries the unchanged cursor the client
1593
+ * needs for the next poll cycle.
1594
+ *
1595
+ * @throws BaerlyError{code:"SchemaError"} — invalid cursor shape, or
1596
+ * the cursor references a log entry that has been folded into a
1597
+ * snapshot and GC'd.
1598
+ */
1599
+ declare function longPollSince(opts: LongPollSinceOptions): Promise<SinceResponse>;
1600
+ /**
1601
+ * One poll cycle: read `current.json`, derive the `seq` range to
1602
+ * scan from the cursor's embedded seq, GET each log entry by `seq`,
1603
+ * return the parsed `LogEntry`s in causal order.
1604
+ *
1605
+ * On-bucket log keys are `log/<seq>.json` — the same shape
1606
+ * `compactor` / `gc` / `rebuild-index` walk. Iterating
1607
+ * `[startSeq, endSeq)` and GET-ing each key directly avoids the
1608
+ * lex-`startAfter` hazard on integer filenames (`10.json` sorts
1609
+ * before `2.json` lex) and gives us the global causal ordering for
1610
+ * free — `seq` is monotonic across writer sessions.
1611
+ *
1612
+ * No `current.json` yet → `[]` (clients can poll a not-yet-existing
1613
+ * collection without erroring). Cursor inside `[0, log_seq_start)` →
1614
+ * `BaerlyError{code:"SchemaError"}`.
1615
+ */
1616
+ declare function listEventsSince(opts: ListEventsSinceOptions): Promise<LogEntry[]>;
1617
+ //#endregion
1618
+ export { type CreateRouterOptions, type ListEventsSinceOptions, type LongPollSinceOptions, MAX_BODY_BYTES, createRouter, listEventsSince, longPollSince, mapError };
1619
+ //# sourceMappingURL=http.d.ts.map