@prisma/query-plan-executor 7.3.0-integration-prisma6-fix-cloudflare-engine.3 → 7.3.0-integration-engines-7-3-0-10-fix-fix-mapped-enum-issue-0b7e6564db7dc3dac7f9312aa84e9ed81d805521.1

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 (3) hide show
  1. package/dist/index.d.ts +293 -2179
  2. package/dist/index.js +1549 -990
  3. package/package.json +7 -7
package/dist/index.d.ts CHANGED
@@ -34,8 +34,14 @@ declare class App {
34
34
  shutdown(): Promise<void>;
35
35
  /**
36
36
  * Executes a query plan and returns the result.
37
+ *
38
+ * @param queryPlan - The query plan to execute
39
+ * @param placeholderValues - Placeholder values for the query
40
+ * @param comments - Pre-computed SQL commenter tags from the client
41
+ * @param resourceLimits - Resource limits for the query
42
+ * @param transactionId - Transaction ID if running within a transaction
37
43
  */
38
- query(queryPlan: QueryPlanNode, placeholderValues: Record<string, unknown>, resourceLimits: ResourceLimits, transactionId: string | null): Promise<unknown>;
44
+ query(queryPlan: QueryPlanNode, placeholderValues: Record<string, unknown>, comments: Record<string, string> | undefined, resourceLimits: ResourceLimits, transactionId: string | null): Promise<unknown>;
39
45
  /**
40
46
  * Starts a new transaction.
41
47
  */
@@ -141,8 +147,8 @@ declare const _baseMimes: {
141
147
  readonly xhtml: "application/xhtml+xml";
142
148
  readonly xml: "application/xml";
143
149
  readonly zip: "application/zip";
144
- readonly "3gp": "video/3gpp";
145
- readonly "3g2": "video/3gpp2";
150
+ readonly '3gp': "video/3gpp";
151
+ readonly '3g2': "video/3gpp2";
146
152
  readonly gltf: "model/gltf+json";
147
153
  readonly glb: "model/gltf-binary";
148
154
  };
@@ -199,10 +205,10 @@ declare type BodyDataValueObject<T> = {
199
205
  * Interface for responding with a body.
200
206
  */
201
207
  declare interface BodyRespond {
202
- <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, "body">;
203
- <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, "body">;
204
- <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, "body">;
205
- <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, "body">;
208
+ <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'body'>;
209
+ <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'body'>;
210
+ <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
211
+ <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
206
212
  }
207
213
 
208
214
  declare type ChangePathOfSchema<S extends Schema, Path extends string> = keyof S extends never ? {
@@ -290,6 +296,7 @@ declare interface Context {
290
296
  }
291
297
 
292
298
  declare class Context_2<E extends Env = any, P extends string = any, I extends Input = {}> {
299
+
293
300
  /**
294
301
  * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
295
302
  *
@@ -303,7 +310,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
303
310
  * })
304
311
  * ```
305
312
  */
306
- env: E["Bindings"];
313
+ env: E['Bindings'];
307
314
  finalized: boolean;
308
315
  /**
309
316
  * `.error` can get the error object from the middleware if the Handler throws an error.
@@ -331,7 +338,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
331
338
  /**
332
339
  * `.req` is the instance of {@link HonoRequest}.
333
340
  */
334
- get req(): HonoRequest<P, I["out"]>;
341
+ get req(): HonoRequest<P, I['out']>;
335
342
  /**
336
343
  * @see {@link https://hono.dev/docs/api/context#event}
337
344
  * The FetchEvent associated with the current request.
@@ -471,7 +478,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
471
478
  * const result = c.var.client.oneMethod()
472
479
  * ```
473
480
  */
474
- get var(): Readonly<ContextVariableMap & (IsAny<E["Variables"]> extends true ? Record<string, any> : E["Variables"])>;
481
+ get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
475
482
  newResponse: NewResponse;
476
483
  /**
477
484
  * `.body()` can return the HTTP response.
@@ -562,7 +569,7 @@ declare type ContextOptions<E extends Env> = {
562
569
  /**
563
570
  * Bindings for the environment.
564
571
  */
565
- env: E["Bindings"];
572
+ env: E['Bindings'];
566
573
  /**
567
574
  * Execution context for the request.
568
575
  */
@@ -571,10 +578,7 @@ declare type ContextOptions<E extends Env> = {
571
578
  * Handler for not found responses.
572
579
  */
573
580
  notFoundHandler?: NotFoundHandler<E>;
574
- matchResult?: Result<[
575
- H,
576
- RouterRoute
577
- ]>;
581
+ matchResult?: Result<[H, RouterRoute]>;
578
582
  path?: string;
579
583
  };
580
584
 
@@ -650,9 +654,12 @@ operation: string;
650
654
  plan: Record<string, unknown>;
651
655
  params: Record<string, unknown>;
652
656
  model?: string | undefined;
657
+ comments?: Record<string, string> | undefined;
653
658
  };
654
659
  };
655
- output: never;
660
+ output: {
661
+ data: JSONValue;
662
+ };
656
663
  outputFormat: "json";
657
664
  status: ContentfulStatusCode;
658
665
  };
@@ -683,13 +690,16 @@ operation: string;
683
690
  plan: Record<string, unknown>;
684
691
  params: Record<string, unknown>;
685
692
  model?: string | undefined;
693
+ comments?: Record<string, string> | undefined;
686
694
  };
687
695
  } & {
688
696
  param: {
689
697
  txId: string;
690
698
  };
691
699
  };
692
- output: never;
700
+ output: {
701
+ data: JSONValue;
702
+ };
693
703
  outputFormat: "json";
694
704
  status: ContentfulStatusCode;
695
705
  };
@@ -881,7 +891,9 @@ declare type ExtendedSpanOptions_2 = SpanOptions & {
881
891
  name: string;
882
892
  };
883
893
 
884
- declare type ExtractInput<I extends Input | Input["in"]> = I extends Input ? unknown extends I["in"] ? {} : I["in"] : I;
894
+ declare type ExtractHandlerResponse<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> ? Exclude<R, void> : never : T extends (c: any, next: any) => infer R ? R extends Response | TypedResponse<any, any, any> ? R : never : never;
895
+
896
+ declare type ExtractInput<I extends Input | Input['in']> = I extends Input ? unknown extends I['in'] ? {} : I['in'] : I;
885
897
 
886
898
  declare type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
887
899
  [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
@@ -963,752 +975,148 @@ declare type Fragment = {
963
975
  * @template E - Environment type.
964
976
  */
965
977
  declare interface Get<E extends Env> {
966
- <Key extends keyof E["Variables"]>(key: Key): E["Variables"][Key];
978
+ <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
967
979
  <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
968
980
  }
969
981
 
970
982
  declare const GET_MATCH_RESULT: symbol;
971
983
 
972
984
  declare type GetPath<E extends Env> = (request: Request, options?: {
973
- env?: E["Bindings"];
985
+ env?: E['Bindings'];
974
986
  }) => string;
975
987
 
976
- declare 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>;
988
+ declare 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>;
977
989
 
978
990
  declare type Handler<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = (c: Context_2<E, P, I>, next: Next) => R;
979
991
 
980
- declare interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = "/"> {
981
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[
982
- E,
983
- E2
984
- ]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
985
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
986
- E,
987
- E2
988
- ]>>(...handlers: [
989
- H<E2, P, I>,
990
- H<E3, P, I2, R>
991
- ]): Hono<IntersectNonAnyTypes<[
992
- E,
993
- E2,
994
- E3
995
- ]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
992
+ declare interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/'> {
993
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
994
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, P, any> = H<E2, P, any>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath>;
996
995
  <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<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
997
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
998
- E,
999
- E2
1000
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1001
- E,
1002
- E2,
1003
- E3
1004
- ]>>(...handlers: [
1005
- H<E2, P, I>,
1006
- H<E3, P, I2>,
1007
- H<E4, P, I3, R>
1008
- ]): Hono<IntersectNonAnyTypes<[
1009
- E,
1010
- E2,
1011
- E3,
1012
- E4
1013
- ]>, S & ToSchema<M, P, I3, MergeTypedResponse<R>>, BasePath>;
1014
- <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<[
1015
- E,
1016
- E2
1017
- ]>>(path: P, ...handlers: [
1018
- H<E2, MergedPath, I>,
1019
- H<E3, MergedPath, I2, R>
1020
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
1021
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1022
- E,
1023
- E2
1024
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1025
- E,
1026
- E2,
1027
- E3
1028
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1029
- E,
1030
- E2,
1031
- E3,
1032
- E4
1033
- ]>>(...handlers: [
1034
- H<E2, P, I>,
1035
- H<E3, P, I2>,
1036
- H<E4, P, I3>,
1037
- H<E5, P, I4, R>
1038
- ]): Hono<IntersectNonAnyTypes<[
1039
- E,
1040
- E2,
1041
- E3,
1042
- E4,
1043
- E5
1044
- ]>, S & ToSchema<M, P, I4, MergeTypedResponse<R>>, BasePath>;
1045
- <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<[
1046
- E,
1047
- E2
1048
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1049
- E,
1050
- E2,
1051
- E3
1052
- ]>>(path: P, ...handlers: [
1053
- H<E2, MergedPath, I>,
1054
- H<E3, MergedPath, I2>,
1055
- H<E4, MergedPath, I3, R>
1056
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
1057
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1058
- E,
1059
- E2
1060
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1061
- E,
1062
- E2,
1063
- E3
1064
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1065
- E,
1066
- E2,
1067
- E3,
1068
- E4
1069
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1070
- E,
1071
- E2,
1072
- E3,
1073
- E4,
1074
- E5
1075
- ]>>(...handlers: [
1076
- H<E2, P, I>,
1077
- H<E3, P, I2>,
1078
- H<E4, P, I3>,
1079
- H<E5, P, I4>,
996
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath>;
997
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath>;
998
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
999
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath>;
1000
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>>(...handlers: [
1001
+ H<E2, P, I> & M1,
1002
+ H<E3, P, I2> & M2,
1003
+ H<E4, P, I3> & M3,
1004
+ H<E5, P, I4> & M4,
1080
1005
  H<E6, P, I5, R>
1081
- ]): Hono<IntersectNonAnyTypes<[
1082
- E,
1083
- E2,
1084
- E3,
1085
- E4,
1086
- E5,
1087
- E6
1088
- ]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
1089
- <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<[
1090
- E,
1091
- E2
1092
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1093
- E,
1094
- E2,
1095
- E3
1096
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1097
- E,
1098
- E2,
1099
- E3,
1100
- E4
1101
- ]>>(path: P, ...handlers: [
1102
- H<E2, MergedPath, I>,
1103
- H<E3, MergedPath, I2>,
1104
- H<E4, MergedPath, I3>,
1006
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
1007
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>>(path: P, ...handlers: [
1008
+ H<E2, MergedPath, I> & M1,
1009
+ H<E3, MergedPath, I2> & M2,
1010
+ H<E4, MergedPath, I3> & M3,
1105
1011
  H<E5, MergedPath, I4, R>
1106
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
1107
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1108
- E,
1109
- E2
1110
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1111
- E,
1112
- E2,
1113
- E3
1114
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1115
- E,
1116
- E2,
1117
- E3,
1118
- E4
1119
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1120
- E,
1121
- E2,
1122
- E3,
1123
- E4,
1124
- E5
1125
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1126
- E,
1127
- E2,
1128
- E3,
1129
- E4,
1130
- E5,
1131
- E6
1132
- ]>>(...handlers: [
1133
- H<E2, P, I>,
1134
- H<E3, P, I2>,
1135
- H<E4, P, I3>,
1136
- H<E5, P, I4>,
1137
- H<E6, P, I5>,
1012
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
1013
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>>(...handlers: [
1014
+ H<E2, P, I> & M1,
1015
+ H<E3, P, I2> & M2,
1016
+ H<E4, P, I3> & M3,
1017
+ H<E5, P, I4> & M4,
1018
+ H<E6, P, I5> & M5,
1138
1019
  H<E7, P, I6, R>
1139
- ]): Hono<IntersectNonAnyTypes<[
1140
- E,
1141
- E2,
1142
- E3,
1143
- E4,
1144
- E5,
1145
- E6,
1146
- E7
1147
- ]>, S & ToSchema<M, P, I6, MergeTypedResponse<R>>, BasePath>;
1148
- <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<[
1149
- E,
1150
- E2
1151
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1152
- E,
1153
- E2,
1154
- E3
1155
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1156
- E,
1157
- E2,
1158
- E3,
1159
- E4
1160
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1161
- E,
1162
- E2,
1163
- E3,
1164
- E4,
1165
- E5
1166
- ]>>(path: P, ...handlers: [
1167
- H<E2, MergedPath, I>,
1168
- H<E3, MergedPath, I2>,
1169
- H<E4, MergedPath, I3>,
1170
- H<E5, MergedPath, I4>,
1020
+ ]): Hono<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>;
1021
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>>(path: P, ...handlers: [
1022
+ H<E2, MergedPath, I> & M1,
1023
+ H<E3, MergedPath, I2> & M2,
1024
+ H<E4, MergedPath, I3> & M3,
1025
+ H<E5, MergedPath, I4> & M4,
1171
1026
  H<E6, MergedPath, I5, R>
1172
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
1173
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1174
- E,
1175
- E2
1176
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1177
- E,
1178
- E2,
1179
- E3
1180
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1181
- E,
1182
- E2,
1183
- E3,
1184
- E4
1185
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1186
- E,
1187
- E2,
1188
- E3,
1189
- E4,
1190
- E5
1191
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1192
- E,
1193
- E2,
1194
- E3,
1195
- E4,
1196
- E5,
1197
- E6
1198
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1199
- E,
1200
- E2,
1201
- E3,
1202
- E4,
1203
- E5,
1204
- E6,
1205
- E7
1206
- ]>>(...handlers: [
1207
- H<E2, P, I>,
1208
- H<E3, P, I2>,
1209
- H<E4, P, I3>,
1210
- H<E5, P, I4>,
1211
- H<E6, P, I5>,
1212
- H<E7, P, I6>,
1027
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
1028
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>>(...handlers: [
1029
+ H<E2, P, I> & M1,
1030
+ H<E3, P, I2> & M2,
1031
+ H<E4, P, I3> & M3,
1032
+ H<E5, P, I4> & M4,
1033
+ H<E6, P, I5> & M5,
1034
+ H<E7, P, I6> & M6,
1213
1035
  H<E8, P, I7, R>
1214
- ]): Hono<IntersectNonAnyTypes<[
1215
- E,
1216
- E2,
1217
- E3,
1218
- E4,
1219
- E5,
1220
- E6,
1221
- E7,
1222
- E8
1223
- ]>, S & ToSchema<M, P, I7, MergeTypedResponse<R>>, BasePath>;
1224
- <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<[
1225
- E,
1226
- E2
1227
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1228
- E,
1229
- E2,
1230
- E3
1231
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1232
- E,
1233
- E2,
1234
- E3,
1235
- E4
1236
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1237
- E,
1238
- E2,
1239
- E3,
1240
- E4,
1241
- E5
1242
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1243
- E,
1244
- E2,
1245
- E3,
1246
- E4,
1247
- E5,
1248
- E6
1249
- ]>>(path: P, ...handlers: [
1250
- H<E2, MergedPath, I>,
1251
- H<E3, MergedPath, I2>,
1252
- H<E4, MergedPath, I3>,
1253
- H<E5, MergedPath, I4>,
1254
- H<E6, MergedPath, I5>,
1036
+ ]): Hono<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>;
1037
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>>(path: P, ...handlers: [
1038
+ H<E2, MergedPath, I> & M1,
1039
+ H<E3, MergedPath, I2> & M2,
1040
+ H<E4, MergedPath, I3> & M3,
1041
+ H<E5, MergedPath, I4> & M4,
1042
+ H<E6, MergedPath, I5> & M5,
1255
1043
  H<E7, MergedPath, I6, R>
1256
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
1257
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1258
- E,
1259
- E2
1260
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1261
- E,
1262
- E2,
1263
- E3
1264
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1265
- E,
1266
- E2,
1267
- E3,
1268
- E4
1269
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1270
- E,
1271
- E2,
1272
- E3,
1273
- E4,
1274
- E5
1275
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1276
- E,
1277
- E2,
1278
- E3,
1279
- E4,
1280
- E5,
1281
- E6
1282
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1283
- E,
1284
- E2,
1285
- E3,
1286
- E4,
1287
- E5,
1288
- E6,
1289
- E7
1290
- ]>, E9 extends Env = IntersectNonAnyTypes<[
1291
- E,
1292
- E2,
1293
- E3,
1294
- E4,
1295
- E5,
1296
- E6,
1297
- E7,
1298
- E8
1299
- ]>>(...handlers: [
1300
- H<E2, P, I>,
1301
- H<E3, P, I2>,
1302
- H<E4, P, I3>,
1303
- H<E5, P, I4>,
1304
- H<E6, P, I5>,
1305
- H<E7, P, I6>,
1306
- H<E8, P, I7>,
1044
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath>;
1045
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>>(...handlers: [
1046
+ H<E2, P, I> & M1,
1047
+ H<E3, P, I2> & M2,
1048
+ H<E4, P, I3> & M3,
1049
+ H<E5, P, I4> & M4,
1050
+ H<E6, P, I5> & M5,
1051
+ H<E7, P, I6> & M6,
1052
+ H<E8, P, I7> & M7,
1307
1053
  H<E9, P, I8, R>
1308
- ]): Hono<IntersectNonAnyTypes<[
1309
- E,
1310
- E2,
1311
- E3,
1312
- E4,
1313
- E5,
1314
- E6,
1315
- E7,
1316
- E8,
1317
- E9
1318
- ]>, S & ToSchema<M, P, I8, MergeTypedResponse<R>>, BasePath>;
1319
- <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<[
1320
- E,
1321
- E2
1322
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1323
- E,
1324
- E2,
1325
- E3
1326
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1327
- E,
1328
- E2,
1329
- E3,
1330
- E4
1331
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1332
- E,
1333
- E2,
1334
- E3,
1335
- E4,
1336
- E5
1337
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1338
- E,
1339
- E2,
1340
- E3,
1341
- E4,
1342
- E5,
1343
- E6
1344
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1345
- E,
1346
- E2,
1347
- E3,
1348
- E4,
1349
- E5,
1350
- E6,
1351
- E7
1352
- ]>>(path: P, ...handlers: [
1353
- H<E2, MergedPath, I>,
1354
- H<E3, MergedPath, I2>,
1355
- H<E4, MergedPath, I3>,
1356
- H<E5, MergedPath, I4>,
1357
- H<E6, MergedPath, I5>,
1358
- H<E7, MergedPath, I6>,
1054
+ ]): Hono<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>;
1055
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>>(path: P, ...handlers: [
1056
+ H<E2, MergedPath, I> & M1,
1057
+ H<E3, MergedPath, I2> & M2,
1058
+ H<E4, MergedPath, I3> & M3,
1059
+ H<E5, MergedPath, I4> & M4,
1060
+ H<E6, MergedPath, I5> & M5,
1061
+ H<E7, MergedPath, I6> & M6,
1359
1062
  H<E8, MergedPath, I7, R>
1360
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
1361
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1362
- E,
1363
- E2
1364
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1365
- E,
1366
- E2,
1367
- E3
1368
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1369
- E,
1370
- E2,
1371
- E3,
1372
- E4
1373
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1374
- E,
1375
- E2,
1376
- E3,
1377
- E4,
1378
- E5
1379
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1380
- E,
1381
- E2,
1382
- E3,
1383
- E4,
1384
- E5,
1385
- E6
1386
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1387
- E,
1388
- E2,
1389
- E3,
1390
- E4,
1391
- E5,
1392
- E6,
1393
- E7
1394
- ]>, E9 extends Env = IntersectNonAnyTypes<[
1395
- E,
1396
- E2,
1397
- E3,
1398
- E4,
1399
- E5,
1400
- E6,
1401
- E7,
1402
- E8
1403
- ]>, E10 extends Env = IntersectNonAnyTypes<[
1404
- E,
1405
- E2,
1406
- E3,
1407
- E4,
1408
- E5,
1409
- E6,
1410
- E7,
1411
- E8,
1412
- E9
1413
- ]>>(...handlers: [
1414
- H<E2, P, I>,
1415
- H<E3, P, I2>,
1416
- H<E4, P, I3>,
1417
- H<E5, P, I4>,
1418
- H<E6, P, I5>,
1419
- H<E7, P, I6>,
1420
- H<E8, P, I7>,
1421
- H<E9, P, I8>,
1063
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath>;
1064
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>>(...handlers: [
1065
+ H<E2, P, I> & M1,
1066
+ H<E3, P, I2> & M2,
1067
+ H<E4, P, I3> & M3,
1068
+ H<E5, P, I4> & M4,
1069
+ H<E6, P, I5> & M5,
1070
+ H<E7, P, I6> & M6,
1071
+ H<E8, P, I7> & M7,
1072
+ H<E9, P, I8> & M8,
1422
1073
  H<E10, P, I9, R>
1423
- ]): Hono<IntersectNonAnyTypes<[
1424
- E,
1425
- E2,
1426
- E3,
1427
- E4,
1428
- E5,
1429
- E6,
1430
- E7,
1431
- E8,
1432
- E9,
1433
- E10
1434
- ]>, S & ToSchema<M, P, I9, MergeTypedResponse<R>>, BasePath>;
1435
- <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<[
1436
- E,
1437
- E2
1438
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1439
- E,
1440
- E2,
1441
- E3
1442
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1443
- E,
1444
- E2,
1445
- E3,
1446
- E4
1447
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1448
- E,
1449
- E2,
1450
- E3,
1451
- E4,
1452
- E5
1453
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1454
- E,
1455
- E2,
1456
- E3,
1457
- E4,
1458
- E5,
1459
- E6
1460
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1461
- E,
1462
- E2,
1463
- E3,
1464
- E4,
1465
- E5,
1466
- E6,
1467
- E7
1468
- ]>, E9 extends Env = IntersectNonAnyTypes<[
1469
- E,
1470
- E2,
1471
- E3,
1472
- E4,
1473
- E5,
1474
- E6,
1475
- E7,
1476
- E8
1477
- ]>>(path: P, ...handlers: [
1478
- H<E2, MergedPath, I>,
1479
- H<E3, MergedPath, I2>,
1480
- H<E4, MergedPath, I3>,
1481
- H<E5, MergedPath, I4>,
1482
- H<E6, MergedPath, I5>,
1483
- H<E7, MergedPath, I6>,
1484
- H<E8, MergedPath, I7>,
1074
+ ]): Hono<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>;
1075
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>>(path: P, ...handlers: [
1076
+ H<E2, MergedPath, I> & M1,
1077
+ H<E3, MergedPath, I2> & M2,
1078
+ H<E4, MergedPath, I3> & M3,
1079
+ H<E5, MergedPath, I4> & M4,
1080
+ H<E6, MergedPath, I5> & M5,
1081
+ H<E7, MergedPath, I6> & M6,
1082
+ H<E8, MergedPath, I7> & M7,
1485
1083
  H<E9, MergedPath, I8, R>
1486
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
1487
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, 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<[
1488
- E,
1489
- E2
1490
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1491
- E,
1492
- E2,
1493
- E3
1494
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1495
- E,
1496
- E2,
1497
- E3,
1498
- E4
1499
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1500
- E,
1501
- E2,
1502
- E3,
1503
- E4,
1504
- E5
1505
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1506
- E,
1507
- E2,
1508
- E3,
1509
- E4,
1510
- E5,
1511
- E6
1512
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1513
- E,
1514
- E2,
1515
- E3,
1516
- E4,
1517
- E5,
1518
- E6,
1519
- E7
1520
- ]>, E9 extends Env = IntersectNonAnyTypes<[
1521
- E,
1522
- E2,
1523
- E3,
1524
- E4,
1525
- E5,
1526
- E6,
1527
- E7,
1528
- E8
1529
- ]>, E10 extends Env = IntersectNonAnyTypes<[
1530
- E,
1531
- E2,
1532
- E3,
1533
- E4,
1534
- E5,
1535
- E6,
1536
- E7,
1537
- E8,
1538
- E9
1539
- ]>, E11 extends Env = IntersectNonAnyTypes<[
1540
- E,
1541
- E2,
1542
- E3,
1543
- E4,
1544
- E5,
1545
- E6,
1546
- E7,
1547
- E8,
1548
- E9,
1549
- E10
1550
- ]>>(...handlers: [
1551
- H<E2, P, I>,
1552
- H<E3, P, I2>,
1553
- H<E4, P, I3>,
1554
- H<E5, P, I4>,
1555
- H<E6, P, I5>,
1556
- H<E7, P, I6>,
1557
- H<E8, P, I7>,
1558
- H<E9, P, I8>,
1559
- H<E10, P, I9>,
1084
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath>;
1085
+ <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>, M9 extends H<E10, P, any> = H<E10, P, any>>(...handlers: [
1086
+ H<E2, P, I> & M1,
1087
+ H<E3, P, I2> & M2,
1088
+ H<E4, P, I3> & M3,
1089
+ H<E5, P, I4> & M4,
1090
+ H<E6, P, I5> & M5,
1091
+ H<E7, P, I6> & M6,
1092
+ H<E8, P, I7> & M7,
1093
+ H<E9, P, I8> & M8,
1094
+ H<E10, P, I9> & M9,
1560
1095
  H<E11, P, I10, R>
1561
- ]): Hono<IntersectNonAnyTypes<[
1562
- E,
1563
- E2,
1564
- E3,
1565
- E4,
1566
- E5,
1567
- E6,
1568
- E7,
1569
- E8,
1570
- E9,
1571
- E10,
1572
- E11
1573
- ]>, S & ToSchema<M, P, I10, MergeTypedResponse<R>>, BasePath>;
1574
- <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<[
1575
- E,
1576
- E2
1577
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1578
- E,
1579
- E2,
1580
- E3
1581
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1582
- E,
1583
- E2,
1584
- E3,
1585
- E4
1586
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1587
- E,
1588
- E2,
1589
- E3,
1590
- E4,
1591
- E5
1592
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1593
- E,
1594
- E2,
1595
- E3,
1596
- E4,
1597
- E5,
1598
- E6
1599
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1600
- E,
1601
- E2,
1602
- E3,
1603
- E4,
1604
- E5,
1605
- E6,
1606
- E7
1607
- ]>, E9 extends Env = IntersectNonAnyTypes<[
1608
- E,
1609
- E2,
1610
- E3,
1611
- E4,
1612
- E5,
1613
- E6,
1614
- E7,
1615
- E8
1616
- ]>, E10 extends Env = IntersectNonAnyTypes<[
1617
- E,
1618
- E2,
1619
- E3,
1620
- E4,
1621
- E5,
1622
- E6,
1623
- E7,
1624
- E8,
1625
- E9
1626
- ]>>(path: P, ...handlers: [
1627
- H<E2, MergedPath, I>,
1628
- H<E3, MergedPath, I2>,
1629
- H<E4, MergedPath, I3>,
1630
- H<E5, MergedPath, I4>,
1631
- H<E6, MergedPath, I5>,
1632
- H<E7, MergedPath, I6>,
1633
- H<E8, MergedPath, I7>,
1634
- H<E9, MergedPath, I8>,
1096
+ ]): Hono<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>;
1097
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>>(path: P, ...handlers: [
1098
+ H<E2, MergedPath, I> & M1,
1099
+ H<E3, MergedPath, I2> & M2,
1100
+ H<E4, MergedPath, I3> & M3,
1101
+ H<E5, MergedPath, I4> & M4,
1102
+ H<E6, MergedPath, I5> & M5,
1103
+ H<E7, MergedPath, I6> & M6,
1104
+ H<E8, MergedPath, I7> & M7,
1105
+ H<E9, MergedPath, I8> & M8,
1635
1106
  H<E10, MergedPath, I9, R>
1636
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
1637
- <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<[
1638
- E,
1639
- E2
1640
- ]>, E4 extends Env = IntersectNonAnyTypes<[
1641
- E,
1642
- E2,
1643
- E3
1644
- ]>, E5 extends Env = IntersectNonAnyTypes<[
1645
- E,
1646
- E2,
1647
- E3,
1648
- E4
1649
- ]>, E6 extends Env = IntersectNonAnyTypes<[
1650
- E,
1651
- E2,
1652
- E3,
1653
- E4,
1654
- E5
1655
- ]>, E7 extends Env = IntersectNonAnyTypes<[
1656
- E,
1657
- E2,
1658
- E3,
1659
- E4,
1660
- E5,
1661
- E6
1662
- ]>, E8 extends Env = IntersectNonAnyTypes<[
1663
- E,
1664
- E2,
1665
- E3,
1666
- E4,
1667
- E5,
1668
- E6,
1669
- E7
1670
- ]>, E9 extends Env = IntersectNonAnyTypes<[
1671
- E,
1672
- E2,
1673
- E3,
1674
- E4,
1675
- E5,
1676
- E6,
1677
- E7,
1678
- E8
1679
- ]>, E10 extends Env = IntersectNonAnyTypes<[
1680
- E,
1681
- E2,
1682
- E3,
1683
- E4,
1684
- E5,
1685
- E6,
1686
- E7,
1687
- E8,
1688
- E9
1689
- ]>, E11 extends Env = IntersectNonAnyTypes<[
1690
- E,
1691
- E2,
1692
- E3,
1693
- E4,
1694
- E5,
1695
- E6,
1696
- E7,
1697
- E8,
1698
- E9,
1699
- E10
1700
- ]>>(path: P, ...handlers: [
1701
- H<E2, MergedPath, I>,
1702
- H<E3, MergedPath, I2>,
1703
- H<E4, MergedPath, I3>,
1704
- H<E5, MergedPath, I4>,
1705
- H<E6, MergedPath, I5>,
1706
- H<E7, MergedPath, I6>,
1707
- H<E8, MergedPath, I7>,
1708
- H<E9, MergedPath, I8>,
1709
- H<E10, MergedPath, I9>,
1107
+ ]): Hono<E, 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>;
1108
+ <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>, M9 extends H<E10, MergedPath, any> = H<E10, MergedPath, any>>(path: P, ...handlers: [
1109
+ H<E2, MergedPath, I> & M1,
1110
+ H<E3, MergedPath, I2> & M2,
1111
+ H<E4, MergedPath, I3> & M3,
1112
+ H<E5, MergedPath, I4> & M4,
1113
+ H<E6, MergedPath, I5> & M5,
1114
+ H<E7, MergedPath, I6> & M6,
1115
+ H<E8, MergedPath, I7> & M7,
1116
+ H<E9, MergedPath, I8> & M8,
1117
+ H<E10, MergedPath, I9> & M9,
1710
1118
  H<E11, MergedPath, I10, R>
1711
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
1119
+ ]): Hono<E, 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>;
1712
1120
  <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
1713
1121
  <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
1714
1122
  <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
@@ -1716,25 +1124,25 @@ declare interface HandlerInterface<E extends Env = Env, M extends string = strin
1716
1124
 
1717
1125
  declare type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
1718
1126
 
1719
- declare type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
1127
+ declare type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
1128
+
1129
+ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
1720
1130
 
1721
- declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = "/"> {
1722
- get: HandlerInterface<E, "get", S, BasePath>;
1723
- post: HandlerInterface<E, "post", S, BasePath>;
1724
- put: HandlerInterface<E, "put", S, BasePath>;
1725
- delete: HandlerInterface<E, "delete", S, BasePath>;
1726
- options: HandlerInterface<E, "options", S, BasePath>;
1727
- patch: HandlerInterface<E, "patch", S, BasePath>;
1728
- all: HandlerInterface<E, "all", S, BasePath>;
1131
+ get: HandlerInterface<E, 'get', S, BasePath>;
1132
+ post: HandlerInterface<E, 'post', S, BasePath>;
1133
+ put: HandlerInterface<E, 'put', S, BasePath>;
1134
+ delete: HandlerInterface<E, 'delete', S, BasePath>;
1135
+ options: HandlerInterface<E, 'options', S, BasePath>;
1136
+ patch: HandlerInterface<E, 'patch', S, BasePath>;
1137
+ all: HandlerInterface<E, 'all', S, BasePath>;
1729
1138
  on: OnHandlerInterface<E, S, BasePath>;
1730
1139
  use: MiddlewareHandlerInterface<E, S, BasePath>;
1731
- router: Router<[
1732
- H,
1733
- RouterRoute
1734
- ]>;
1140
+ router: Router<[H, RouterRoute]>;
1735
1141
  readonly getPath: GetPath<E>;
1142
+ private _basePath;
1736
1143
  routes: RouterRoute[];
1737
1144
  constructor(options?: HonoOptions<E>);
1145
+ private errorHandler;
1738
1146
  /**
1739
1147
  * `.route()` allows grouping other Hono instance in routes.
1740
1148
  *
@@ -1845,7 +1253,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
1845
1253
  * @returns {Response | Promise<Response>} response of request
1846
1254
  *
1847
1255
  */
1848
- fetch: (request: Request, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1256
+ fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1849
1257
  /**
1850
1258
  * `.request()` is a useful method for testing.
1851
1259
  * You can pass a URL or pathname to send a GET request.
@@ -1898,10 +1306,7 @@ declare type HonoOptions<E extends Env> = {
1898
1306
  * const app = new Hono({ router: new RegExpRouter() })
1899
1307
  * ```
1900
1308
  */
1901
- router?: Router<[
1902
- H,
1903
- RouterRoute
1904
- ]>;
1309
+ router?: Router<[H, RouterRoute]>;
1905
1310
  /**
1906
1311
  * `getPath` can handle the host header value.
1907
1312
  *
@@ -1925,11 +1330,9 @@ declare type HonoOptions<E extends Env> = {
1925
1330
  getPath?: GetPath<E>;
1926
1331
  };
1927
1332
 
1928
- declare class HonoRequest<P extends string = "/", I extends Input["out"] = {}> {
1929
- [GET_MATCH_RESULT]: Result<[
1930
- unknown,
1931
- RouterRoute
1932
- ]>;
1333
+ declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
1334
+
1335
+ [GET_MATCH_RESULT]: Result<[unknown, RouterRoute]>;
1933
1336
  /**
1934
1337
  * `.raw` can get the raw Request object.
1935
1338
  *
@@ -1960,10 +1363,7 @@ declare class HonoRequest<P extends string = "/", I extends Input["out"] = {}> {
1960
1363
  */
1961
1364
  path: string;
1962
1365
  bodyCache: BodyCache;
1963
- constructor(request: Request, path?: string, matchResult?: Result<[
1964
- unknown,
1965
- RouterRoute
1966
- ]>);
1366
+ constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
1967
1367
  /**
1968
1368
  * `.req.param()` gets the path parameters.
1969
1369
  *
@@ -2261,14 +1661,11 @@ declare type Input = {
2261
1661
  outputFormat?: ResponseFormat;
2262
1662
  };
2263
1663
 
2264
- declare type InputToDataByTarget<T extends Input["out"], Target extends keyof ValidationTargets> = T extends {
1664
+ declare type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends {
2265
1665
  [K in Target]: infer R;
2266
1666
  } ? R : never;
2267
1667
 
2268
- declare type IntersectNonAnyTypes<T extends any[]> = T extends [
2269
- infer Head,
2270
- ...infer Rest
2271
- ] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
1668
+ declare type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
2272
1669
 
2273
1670
  declare type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
2274
1671
 
@@ -2293,15 +1690,28 @@ declare type JSONObject = {
2293
1690
  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
2294
1691
  };
2295
1692
 
2296
- declare type JSONParsed<T> = T extends {
1693
+ /**
1694
+ * Convert a type to a JSON-compatible type.
1695
+ *
1696
+ * Non-JSON values such as `Date` implement `.toJSON()`,
1697
+ * so they can be transformed to a value assignable to `JSONObject`
1698
+ *
1699
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
1700
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
1701
+ *
1702
+ * This behaviour can be controlled by the `TError` generic type parameter,
1703
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
1704
+ * You can set it to `never` to disable this check.
1705
+ */
1706
+ declare type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
2297
1707
  toJSON(): infer J;
2298
1708
  } ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
2299
1709
  toJSON(): unknown;
2300
- } ? {} : JSONParsed<J> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
2301
- [K in keyof T]: JSONParsed<InvalidToNull<T[K]>>;
2302
- } : T extends Set<unknown> | Map<unknown, unknown> ? {} : T extends object ? {
2303
- [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K]> | undefined : JSONParsed<T[K]>;
2304
- } : never;
1710
+ } ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
1711
+ [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
1712
+ } : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
1713
+ [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>;
1714
+ } : T extends unknown ? T extends TError ? never : JSONValue : never;
2305
1715
 
2306
1716
  declare type JSONPrimitive = string | boolean | number | null;
2307
1717
 
@@ -2319,21 +1729,21 @@ declare type JSONPrimitive = string | boolean | number | null;
2319
1729
  * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
2320
1730
  */
2321
1731
  declare interface JSONRespond {
2322
- <T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
2323
- <T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
1732
+ <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
1733
+ <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
2324
1734
  }
2325
1735
 
2326
1736
  /**
2327
1737
  * @template T - The type of the JSON value or simplified unknown type.
2328
1738
  * @template U - The type of the status code.
2329
1739
  *
2330
- * @returns {Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? (JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T>) : never, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
1740
+ * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
2331
1741
  */
2332
- declare type JSONRespondReturn<T extends JSONValue | SimplifyDeepArray<unknown> | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<SimplifyDeepArray<T> extends JSONValue ? JSONValue extends SimplifyDeepArray<T> ? never : JSONParsed<T> : never, U, "json">;
1742
+ declare type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
2333
1743
 
2334
1744
  declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
2335
1745
 
2336
- declare type KnownResponseFormat = "json" | "text" | "redirect";
1746
+ declare type KnownResponseFormat = 'json' | 'text' | 'redirect';
2337
1747
 
2338
1748
  declare type Layout<T = Record<string, any>> = (props: T) => any;
2339
1749
 
@@ -2475,28 +1885,28 @@ declare interface LogSink {
2475
1885
  }
2476
1886
 
2477
1887
  declare type MergeEndpointParamsWithPath<T extends Endpoint, SubPath extends string> = T extends unknown ? {
2478
- input: T["input"] extends {
1888
+ input: T['input'] extends {
2479
1889
  param: infer _;
2480
- } ? ExtractParams<SubPath> extends never ? T["input"] : FlattenIfIntersect<T["input"] & {
1890
+ } ? ExtractParams<SubPath> extends never ? T['input'] : FlattenIfIntersect<T['input'] & {
2481
1891
  param: {
2482
1892
  [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
2483
1893
  };
2484
- }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T["input"] : T["input"] & {
1894
+ }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T['input'] : T['input'] & {
2485
1895
  param: {
2486
1896
  [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
2487
1897
  };
2488
1898
  };
2489
- output: T["output"];
2490
- outputFormat: T["outputFormat"];
2491
- status: T["status"];
1899
+ output: T['output'];
1900
+ outputFormat: T['outputFormat'];
1901
+ status: T['status'];
2492
1902
  } : never;
2493
1903
 
2494
- declare 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}`;
1904
+ declare type MergeMiddlewareResponse<T> = MergeTypedResponseStrict<ExtractHandlerResponse<T>>;
1905
+
1906
+ declare 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}`;
2495
1907
 
2496
1908
  declare type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = {
2497
- [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [
2498
- OrigSchema[P]
2499
- ] extends [
1909
+ [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [OrigSchema[P]] extends [
2500
1910
  Record<string, Endpoint>
2501
1911
  ] ? {
2502
1912
  [M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath>;
@@ -2505,264 +1915,57 @@ declare type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string>
2505
1915
 
2506
1916
  declare type MergeTypedResponse<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;
2507
1917
 
2508
- declare type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}> = (c: Context_2<E, P, I>, next: Next) => Promise<Response | void>;
2509
-
2510
- declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/"> {
2511
- <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>[]): Hono<IntersectNonAnyTypes<[
2512
- E,
2513
- E2
2514
- ]>, S, BasePath>;
2515
- <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>): Hono<IntersectNonAnyTypes<[
2516
- E,
2517
- E2
2518
- ]>, S, BasePath>;
2519
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2520
- E,
2521
- E2
2522
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
2523
- MiddlewareHandler<E2, P>,
2524
- MiddlewareHandler<E3, P>
2525
- ]): Hono<IntersectNonAnyTypes<[
2526
- E,
2527
- E2,
2528
- E3
2529
- ]>, S, BasePath>;
2530
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath>): Hono<IntersectNonAnyTypes<[
2531
- E,
2532
- E2
2533
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2534
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2535
- E,
2536
- E2
2537
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2538
- E,
2539
- E2,
2540
- E3
2541
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
2542
- MiddlewareHandler<E2, P>,
2543
- MiddlewareHandler<E3, P>,
2544
- MiddlewareHandler<E4, P>
2545
- ]): Hono<IntersectNonAnyTypes<[
2546
- E,
2547
- E2,
2548
- E3,
2549
- E4
2550
- ]>, S, BasePath>;
2551
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2552
- E,
2553
- E2
2554
- ]>>(path: P, ...handlers: [
2555
- MiddlewareHandler<E2, P>,
2556
- MiddlewareHandler<E3, P>
2557
- ]): Hono<IntersectNonAnyTypes<[
2558
- E,
2559
- E2,
2560
- E3
2561
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2562
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2563
- E,
2564
- E2
2565
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2566
- E,
2567
- E2,
2568
- E3
2569
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2570
- E,
2571
- E2,
2572
- E3,
2573
- E4
2574
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1918
+ declare type MergeTypedResponseStrict<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : never : T extends TypedResponse ? T : never;
1919
+
1920
+ declare type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> = Response> = (c: Context_2<E, P, I>, next: Next) => Promise<R | void>;
1921
+
1922
+ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
1923
+ <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
1924
+ <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
1925
+ <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath>;
1926
+ <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath, any, any>): Hono<IntersectNonAnyTypes<[E, E2]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1927
+ <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1928
+ MiddlewareHandler<E2, P, any, any>,
1929
+ MiddlewareHandler<E3, P, any, any>,
1930
+ MiddlewareHandler<E4, P, any, any>
1931
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath>;
1932
+ <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<IntersectNonAnyTypes<[E, E2, E3]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1933
+ <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, ExtractStringKey<S>>>(...handlers: [
2575
1934
  MiddlewareHandler<E2, P>,
2576
1935
  MiddlewareHandler<E3, P>,
2577
1936
  MiddlewareHandler<E4, P>,
2578
1937
  MiddlewareHandler<E5, P>
2579
- ]): Hono<IntersectNonAnyTypes<[
2580
- E,
2581
- E2,
2582
- E3,
2583
- E4,
2584
- E5
2585
- ]>, S, BasePath>;
2586
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2587
- E,
2588
- E2
2589
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2590
- E,
2591
- E2,
2592
- E3
2593
- ]>>(path: P, ...handlers: [
2594
- MiddlewareHandler<E2, P>,
2595
- MiddlewareHandler<E3, P>,
2596
- MiddlewareHandler<E4, P>
2597
- ]): Hono<IntersectNonAnyTypes<[
2598
- E,
2599
- E2,
2600
- E3,
2601
- E4
2602
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2603
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2604
- E,
2605
- E2
2606
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2607
- E,
2608
- E2,
2609
- E3
2610
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2611
- E,
2612
- E2,
2613
- E3,
2614
- E4
2615
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2616
- E,
2617
- E2,
2618
- E3,
2619
- E4,
2620
- E5
2621
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1938
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath>;
1939
+ <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<IntersectNonAnyTypes<[E, E2, E3, E4]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1940
+ <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, ExtractStringKey<S>>>(...handlers: [
2622
1941
  MiddlewareHandler<E2, P>,
2623
1942
  MiddlewareHandler<E3, P>,
2624
1943
  MiddlewareHandler<E4, P>,
2625
1944
  MiddlewareHandler<E5, P>,
2626
1945
  MiddlewareHandler<E6, P>
2627
- ]): Hono<IntersectNonAnyTypes<[
2628
- E,
2629
- E2,
2630
- E3,
2631
- E4,
2632
- E5,
2633
- E6
2634
- ]>, S, BasePath>;
2635
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2636
- E,
2637
- E2
2638
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2639
- E,
2640
- E2,
2641
- E3
2642
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2643
- E,
2644
- E2,
2645
- E3,
2646
- E4
2647
- ]>>(path: P, ...handlers: [
1946
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath>;
1947
+ <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: [
2648
1948
  MiddlewareHandler<E2, P>,
2649
1949
  MiddlewareHandler<E3, P>,
2650
1950
  MiddlewareHandler<E4, P>,
2651
1951
  MiddlewareHandler<E5, P>
2652
- ]): Hono<IntersectNonAnyTypes<[
2653
- E,
2654
- E2,
2655
- E3,
2656
- E4,
2657
- E5
2658
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2659
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2660
- E,
2661
- E2
2662
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2663
- E,
2664
- E2,
2665
- E3
2666
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2667
- E,
2668
- E2,
2669
- E3,
2670
- E4
2671
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2672
- E,
2673
- E2,
2674
- E3,
2675
- E4,
2676
- E5
2677
- ]>, E7 extends Env = IntersectNonAnyTypes<[
2678
- E,
2679
- E2,
2680
- E3,
2681
- E4,
2682
- E5,
2683
- E6
2684
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1952
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1953
+ <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, ExtractStringKey<S>>>(...handlers: [
2685
1954
  MiddlewareHandler<E2, P>,
2686
1955
  MiddlewareHandler<E3, P>,
2687
1956
  MiddlewareHandler<E4, P>,
2688
1957
  MiddlewareHandler<E5, P>,
2689
1958
  MiddlewareHandler<E6, P>,
2690
1959
  MiddlewareHandler<E7, P>
2691
- ]): Hono<IntersectNonAnyTypes<[
2692
- E,
2693
- E2,
2694
- E3,
2695
- E4,
2696
- E5,
2697
- E6,
2698
- E7
2699
- ]>, S, BasePath>;
2700
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2701
- E,
2702
- E2
2703
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2704
- E,
2705
- E2,
2706
- E3
2707
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2708
- E,
2709
- E2,
2710
- E3,
2711
- E4
2712
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2713
- E,
2714
- E2,
2715
- E3,
2716
- E4,
2717
- E5
2718
- ]>>(path: P, ...handlers: [
1960
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath>;
1961
+ <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: [
2719
1962
  MiddlewareHandler<E2, P>,
2720
1963
  MiddlewareHandler<E3, P>,
2721
1964
  MiddlewareHandler<E4, P>,
2722
1965
  MiddlewareHandler<E5, P>,
2723
1966
  MiddlewareHandler<E6, P>
2724
- ]): Hono<IntersectNonAnyTypes<[
2725
- E,
2726
- E2,
2727
- E3,
2728
- E4,
2729
- E5,
2730
- E6
2731
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2732
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2733
- E,
2734
- E2
2735
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2736
- E,
2737
- E2,
2738
- E3
2739
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2740
- E,
2741
- E2,
2742
- E3,
2743
- E4
2744
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2745
- E,
2746
- E2,
2747
- E3,
2748
- E4,
2749
- E5
2750
- ]>, E7 extends Env = IntersectNonAnyTypes<[
2751
- E,
2752
- E2,
2753
- E3,
2754
- E4,
2755
- E5,
2756
- E6
2757
- ]>, E8 extends Env = IntersectNonAnyTypes<[
2758
- E,
2759
- E2,
2760
- E3,
2761
- E4,
2762
- E5,
2763
- E6,
2764
- E7
2765
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1967
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1968
+ <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, ExtractStringKey<S>>>(...handlers: [
2766
1969
  MiddlewareHandler<E2, P>,
2767
1970
  MiddlewareHandler<E3, P>,
2768
1971
  MiddlewareHandler<E4, P>,
@@ -2770,100 +1973,16 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2770
1973
  MiddlewareHandler<E6, P>,
2771
1974
  MiddlewareHandler<E7, P>,
2772
1975
  MiddlewareHandler<E8, P>
2773
- ]): Hono<IntersectNonAnyTypes<[
2774
- E,
2775
- E2,
2776
- E3,
2777
- E4,
2778
- E5,
2779
- E6,
2780
- E7,
2781
- E8
2782
- ]>, S, BasePath>;
2783
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2784
- E,
2785
- E2
2786
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2787
- E,
2788
- E2,
2789
- E3
2790
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2791
- E,
2792
- E2,
2793
- E3,
2794
- E4
2795
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2796
- E,
2797
- E2,
2798
- E3,
2799
- E4,
2800
- E5
2801
- ]>, E7 extends Env = IntersectNonAnyTypes<[
2802
- E,
2803
- E2,
2804
- E3,
2805
- E4,
2806
- E5,
2807
- E6
2808
- ]>>(path: P, ...handlers: [
1976
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath>;
1977
+ <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: [
2809
1978
  MiddlewareHandler<E2, P>,
2810
1979
  MiddlewareHandler<E3, P>,
2811
1980
  MiddlewareHandler<E4, P>,
2812
1981
  MiddlewareHandler<E5, P>,
2813
1982
  MiddlewareHandler<E6, P>,
2814
1983
  MiddlewareHandler<E7, P>
2815
- ]): Hono<IntersectNonAnyTypes<[
2816
- E,
2817
- E2,
2818
- E3,
2819
- E4,
2820
- E5,
2821
- E6,
2822
- E7
2823
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2824
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2825
- E,
2826
- E2
2827
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2828
- E,
2829
- E2,
2830
- E3
2831
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2832
- E,
2833
- E2,
2834
- E3,
2835
- E4
2836
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2837
- E,
2838
- E2,
2839
- E3,
2840
- E4,
2841
- E5
2842
- ]>, E7 extends Env = IntersectNonAnyTypes<[
2843
- E,
2844
- E2,
2845
- E3,
2846
- E4,
2847
- E5,
2848
- E6
2849
- ]>, E8 extends Env = IntersectNonAnyTypes<[
2850
- E,
2851
- E2,
2852
- E3,
2853
- E4,
2854
- E5,
2855
- E6,
2856
- E7
2857
- ]>, E9 extends Env = IntersectNonAnyTypes<[
2858
- E,
2859
- E2,
2860
- E3,
2861
- E4,
2862
- E5,
2863
- E6,
2864
- E7,
2865
- E8
2866
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1984
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1985
+ <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, ExtractStringKey<S>>>(...handlers: [
2867
1986
  MiddlewareHandler<E2, P>,
2868
1987
  MiddlewareHandler<E3, P>,
2869
1988
  MiddlewareHandler<E4, P>,
@@ -2872,51 +1991,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2872
1991
  MiddlewareHandler<E7, P>,
2873
1992
  MiddlewareHandler<E8, P>,
2874
1993
  MiddlewareHandler<E9, P>
2875
- ]): Hono<IntersectNonAnyTypes<[
2876
- E,
2877
- E2,
2878
- E3,
2879
- E4,
2880
- E5,
2881
- E6,
2882
- E7,
2883
- E8,
2884
- E9
2885
- ]>, S, BasePath>;
2886
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2887
- E,
2888
- E2
2889
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2890
- E,
2891
- E2,
2892
- E3
2893
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2894
- E,
2895
- E2,
2896
- E3,
2897
- E4
2898
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2899
- E,
2900
- E2,
2901
- E3,
2902
- E4,
2903
- E5
2904
- ]>, E7 extends Env = IntersectNonAnyTypes<[
2905
- E,
2906
- E2,
2907
- E3,
2908
- E4,
2909
- E5,
2910
- E6
2911
- ]>, E8 extends Env = IntersectNonAnyTypes<[
2912
- E,
2913
- E2,
2914
- E3,
2915
- E4,
2916
- E5,
2917
- E6,
2918
- E7
2919
- ]>>(path: P, ...handlers: [
1994
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath>;
1995
+ <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: [
2920
1996
  MiddlewareHandler<E2, P>,
2921
1997
  MiddlewareHandler<E3, P>,
2922
1998
  MiddlewareHandler<E4, P>,
@@ -2924,69 +2000,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2924
2000
  MiddlewareHandler<E6, P>,
2925
2001
  MiddlewareHandler<E7, P>,
2926
2002
  MiddlewareHandler<E8, P>
2927
- ]): Hono<IntersectNonAnyTypes<[
2928
- E,
2929
- E2,
2930
- E3,
2931
- E4,
2932
- E5,
2933
- E6,
2934
- E7,
2935
- E8
2936
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2937
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
2938
- E,
2939
- E2
2940
- ]>, E4 extends Env = IntersectNonAnyTypes<[
2941
- E,
2942
- E2,
2943
- E3
2944
- ]>, E5 extends Env = IntersectNonAnyTypes<[
2945
- E,
2946
- E2,
2947
- E3,
2948
- E4
2949
- ]>, E6 extends Env = IntersectNonAnyTypes<[
2950
- E,
2951
- E2,
2952
- E3,
2953
- E4,
2954
- E5
2955
- ]>, E7 extends Env = IntersectNonAnyTypes<[
2956
- E,
2957
- E2,
2958
- E3,
2959
- E4,
2960
- E5,
2961
- E6
2962
- ]>, E8 extends Env = IntersectNonAnyTypes<[
2963
- E,
2964
- E2,
2965
- E3,
2966
- E4,
2967
- E5,
2968
- E6,
2969
- E7
2970
- ]>, E9 extends Env = IntersectNonAnyTypes<[
2971
- E,
2972
- E2,
2973
- E3,
2974
- E4,
2975
- E5,
2976
- E6,
2977
- E7,
2978
- E8
2979
- ]>, E10 extends Env = IntersectNonAnyTypes<[
2980
- E,
2981
- E2,
2982
- E3,
2983
- E4,
2984
- E5,
2985
- E6,
2986
- E7,
2987
- E8,
2988
- E9
2989
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
2003
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2004
+ <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, ExtractStringKey<S>>>(...handlers: [
2990
2005
  MiddlewareHandler<E2, P>,
2991
2006
  MiddlewareHandler<E3, P>,
2992
2007
  MiddlewareHandler<E4, P>,
@@ -2996,61 +2011,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2996
2011
  MiddlewareHandler<E8, P>,
2997
2012
  MiddlewareHandler<E9, P>,
2998
2013
  MiddlewareHandler<E10, P>
2999
- ]): Hono<IntersectNonAnyTypes<[
3000
- E,
3001
- E2,
3002
- E3,
3003
- E4,
3004
- E5,
3005
- E6,
3006
- E7,
3007
- E8,
3008
- E9,
3009
- E10
3010
- ]>, S, BasePath>;
3011
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
3012
- E,
3013
- E2
3014
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3015
- E,
3016
- E2,
3017
- E3
3018
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3019
- E,
3020
- E2,
3021
- E3,
3022
- E4
3023
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3024
- E,
3025
- E2,
3026
- E3,
3027
- E4,
3028
- E5
3029
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3030
- E,
3031
- E2,
3032
- E3,
3033
- E4,
3034
- E5,
3035
- E6
3036
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3037
- E,
3038
- E2,
3039
- E3,
3040
- E4,
3041
- E5,
3042
- E6,
3043
- E7
3044
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3045
- E,
3046
- E2,
3047
- E3,
3048
- E4,
3049
- E5,
3050
- E6,
3051
- E7,
3052
- E8
3053
- ]>>(path: P, ...handlers: [
2014
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath>;
2015
+ <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: [
3054
2016
  MiddlewareHandler<E2, P>,
3055
2017
  MiddlewareHandler<E3, P>,
3056
2018
  MiddlewareHandler<E4, P>,
@@ -3059,81 +2021,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
3059
2021
  MiddlewareHandler<E7, P>,
3060
2022
  MiddlewareHandler<E8, P>,
3061
2023
  MiddlewareHandler<E9, P>
3062
- ]): Hono<IntersectNonAnyTypes<[
3063
- E,
3064
- E2,
3065
- E3,
3066
- E4,
3067
- E5,
3068
- E6,
3069
- E7,
3070
- E8,
3071
- E9
3072
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
3073
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
3074
- E,
3075
- E2
3076
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3077
- E,
3078
- E2,
3079
- E3
3080
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3081
- E,
3082
- E2,
3083
- E3,
3084
- E4
3085
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3086
- E,
3087
- E2,
3088
- E3,
3089
- E4,
3090
- E5
3091
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3092
- E,
3093
- E2,
3094
- E3,
3095
- E4,
3096
- E5,
3097
- E6
3098
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3099
- E,
3100
- E2,
3101
- E3,
3102
- E4,
3103
- E5,
3104
- E6,
3105
- E7
3106
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3107
- E,
3108
- E2,
3109
- E3,
3110
- E4,
3111
- E5,
3112
- E6,
3113
- E7,
3114
- E8
3115
- ]>, E10 extends Env = IntersectNonAnyTypes<[
3116
- E,
3117
- E2,
3118
- E3,
3119
- E4,
3120
- E5,
3121
- E6,
3122
- E7,
3123
- E8,
3124
- E9
3125
- ]>, E11 extends Env = IntersectNonAnyTypes<[
3126
- E,
3127
- E2,
3128
- E3,
3129
- E4,
3130
- E5,
3131
- E6,
3132
- E7,
3133
- E8,
3134
- E9,
3135
- E10
3136
- ]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
2024
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2025
+ <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, ExtractStringKey<S>>>(...handlers: [
3137
2026
  MiddlewareHandler<E2, P>,
3138
2027
  MiddlewareHandler<E3, P>,
3139
2028
  MiddlewareHandler<E4, P>,
@@ -3144,72 +2033,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
3144
2033
  MiddlewareHandler<E9, P>,
3145
2034
  MiddlewareHandler<E10, P>,
3146
2035
  MiddlewareHandler<E11, P>
3147
- ]): Hono<IntersectNonAnyTypes<[
3148
- E,
3149
- E2,
3150
- E3,
3151
- E4,
3152
- E5,
3153
- E6,
3154
- E7,
3155
- E8,
3156
- E9,
3157
- E10,
3158
- E11
3159
- ]>, S, BasePath>;
3160
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
3161
- E,
3162
- E2
3163
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3164
- E,
3165
- E2,
3166
- E3
3167
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3168
- E,
3169
- E2,
3170
- E3,
3171
- E4
3172
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3173
- E,
3174
- E2,
3175
- E3,
3176
- E4,
3177
- E5
3178
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3179
- E,
3180
- E2,
3181
- E3,
3182
- E4,
3183
- E5,
3184
- E6
3185
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3186
- E,
3187
- E2,
3188
- E3,
3189
- E4,
3190
- E5,
3191
- E6,
3192
- E7
3193
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3194
- E,
3195
- E2,
3196
- E3,
3197
- E4,
3198
- E5,
3199
- E6,
3200
- E7,
3201
- E8
3202
- ]>, E10 extends Env = IntersectNonAnyTypes<[
3203
- E,
3204
- E2,
3205
- E3,
3206
- E4,
3207
- E5,
3208
- E6,
3209
- E7,
3210
- E8,
3211
- E9
3212
- ]>>(path: P, ...handlers: [
2036
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath>;
2037
+ <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: [
3213
2038
  MiddlewareHandler<E2, P>,
3214
2039
  MiddlewareHandler<E3, P>,
3215
2040
  MiddlewareHandler<E4, P>,
@@ -3219,18 +2044,7 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
3219
2044
  MiddlewareHandler<E8, P>,
3220
2045
  MiddlewareHandler<E9, P>,
3221
2046
  MiddlewareHandler<E10, P>
3222
- ]): Hono<IntersectNonAnyTypes<[
3223
- E,
3224
- E2,
3225
- E3,
3226
- E4,
3227
- E5,
3228
- E6,
3229
- E7,
3230
- E8,
3231
- E9,
3232
- E10
3233
- ]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2047
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
3234
2048
  <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
3235
2049
  }
3236
2050
 
@@ -3264,170 +2078,32 @@ declare type OmitSymbolKeys<T> = {
3264
2078
  [K in keyof T as K extends symbol ? never : K]: T[K];
3265
2079
  };
3266
2080
 
3267
- declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/"> {
3268
- <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<IntersectNonAnyTypes<[
3269
- E,
3270
- E2
3271
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
3272
- <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<[
3273
- E,
3274
- E2
3275
- ]>>(method: M, path: P, ...handlers: [
3276
- H<E2, MergedPath, I>,
3277
- H<E3, MergedPath, I2, R>
3278
- ]): Hono<IntersectNonAnyTypes<[
3279
- E,
3280
- E2,
3281
- E3
3282
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
3283
- <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<[
3284
- E,
3285
- E2
3286
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3287
- E,
3288
- E2,
3289
- E3
3290
- ]>>(method: M, path: P, ...handlers: [
3291
- H<E2, MergedPath, I>,
3292
- H<E3, MergedPath, I2>,
3293
- H<E4, MergedPath, I3, R>
3294
- ]): Hono<IntersectNonAnyTypes<[
3295
- E,
3296
- E2,
3297
- E3,
3298
- E4
3299
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
3300
- <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<[
3301
- E,
3302
- E2
3303
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3304
- E,
3305
- E2,
3306
- E3
3307
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3308
- E,
3309
- E2,
3310
- E3,
3311
- E4
3312
- ]>>(method: M, path: P, ...handlers: [
2081
+ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
2082
+ <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<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
2083
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
2084
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
2085
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(method: M, path: P, ...handlers: [
3313
2086
  H<E2, MergedPath, I>,
3314
2087
  H<E3, MergedPath, I2>,
3315
2088
  H<E4, MergedPath, I3>,
3316
2089
  H<E5, MergedPath, I4, R>
3317
- ]): Hono<IntersectNonAnyTypes<[
3318
- E,
3319
- E2,
3320
- E3,
3321
- E4,
3322
- E5
3323
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
3324
- <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<[
3325
- E,
3326
- E2
3327
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3328
- E,
3329
- E2,
3330
- E3
3331
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3332
- E,
3333
- E2,
3334
- E3,
3335
- E4
3336
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3337
- E,
3338
- E2,
3339
- E3,
3340
- E4,
3341
- E5
3342
- ]>>(method: M, path: P, ...handlers: [
2090
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
2091
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(method: M, path: P, ...handlers: [
3343
2092
  H<E2, MergedPath, I>,
3344
2093
  H<E3, MergedPath, I2>,
3345
2094
  H<E4, MergedPath, I3>,
3346
2095
  H<E5, MergedPath, I4>,
3347
2096
  H<E6, MergedPath, I5, R>
3348
- ]): Hono<IntersectNonAnyTypes<[
3349
- E,
3350
- E2,
3351
- E3,
3352
- E4,
3353
- E5,
3354
- E6
3355
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
3356
- <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<[
3357
- E,
3358
- E2
3359
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3360
- E,
3361
- E2,
3362
- E3
3363
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3364
- E,
3365
- E2,
3366
- E3,
3367
- E4
3368
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3369
- E,
3370
- E2,
3371
- E3,
3372
- E4,
3373
- E5
3374
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3375
- E,
3376
- E2,
3377
- E3,
3378
- E4,
3379
- E5,
3380
- E6
3381
- ]>>(method: M, path: P, ...handlers: [
2097
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
2098
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(method: M, path: P, ...handlers: [
3382
2099
  H<E2, MergedPath, I>,
3383
2100
  H<E3, MergedPath, I2>,
3384
2101
  H<E4, MergedPath, I3>,
3385
2102
  H<E5, MergedPath, I4>,
3386
2103
  H<E6, MergedPath, I5>,
3387
2104
  H<E7, MergedPath, I6, R>
3388
- ]): Hono<IntersectNonAnyTypes<[
3389
- E,
3390
- E2,
3391
- E3,
3392
- E4,
3393
- E5,
3394
- E6,
3395
- E7
3396
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
3397
- <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<[
3398
- E,
3399
- E2
3400
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3401
- E,
3402
- E2,
3403
- E3
3404
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3405
- E,
3406
- E2,
3407
- E3,
3408
- E4
3409
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3410
- E,
3411
- E2,
3412
- E3,
3413
- E4,
3414
- E5
3415
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3416
- E,
3417
- E2,
3418
- E3,
3419
- E4,
3420
- E5,
3421
- E6
3422
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3423
- E,
3424
- E2,
3425
- E3,
3426
- E4,
3427
- E5,
3428
- E6,
3429
- E7
3430
- ]>>(method: M, path: P, ...handlers: [
2105
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
2106
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(method: M, path: P, ...handlers: [
3431
2107
  H<E2, MergedPath, I>,
3432
2108
  H<E3, MergedPath, I2>,
3433
2109
  H<E4, MergedPath, I3>,
@@ -3435,59 +2111,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3435
2111
  H<E6, MergedPath, I5>,
3436
2112
  H<E7, MergedPath, I6>,
3437
2113
  H<E8, MergedPath, I7, R>
3438
- ]): Hono<IntersectNonAnyTypes<[
3439
- E,
3440
- E2,
3441
- E3,
3442
- E4,
3443
- E5,
3444
- E6,
3445
- E7,
3446
- E8
3447
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
3448
- <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<[
3449
- E,
3450
- E2
3451
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3452
- E,
3453
- E2,
3454
- E3
3455
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3456
- E,
3457
- E2,
3458
- E3,
3459
- E4
3460
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3461
- E,
3462
- E2,
3463
- E3,
3464
- E4,
3465
- E5
3466
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3467
- E,
3468
- E2,
3469
- E3,
3470
- E4,
3471
- E5,
3472
- E6
3473
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3474
- E,
3475
- E2,
3476
- E3,
3477
- E4,
3478
- E5,
3479
- E6,
3480
- E7
3481
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3482
- E,
3483
- E2,
3484
- E3,
3485
- E4,
3486
- E5,
3487
- E6,
3488
- E7,
3489
- E8
3490
- ]>>(method: M, path: P, ...handlers: [
2114
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
2115
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(method: M, path: P, ...handlers: [
3491
2116
  H<E2, MergedPath, I>,
3492
2117
  H<E3, MergedPath, I2>,
3493
2118
  H<E4, MergedPath, I3>,
@@ -3496,70 +2121,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3496
2121
  H<E7, MergedPath, I6>,
3497
2122
  H<E8, MergedPath, I7>,
3498
2123
  H<E9, MergedPath, I8, R>
3499
- ]): Hono<IntersectNonAnyTypes<[
3500
- E,
3501
- E2,
3502
- E3,
3503
- E4,
3504
- E5,
3505
- E6,
3506
- E7,
3507
- E8,
3508
- E9
3509
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
3510
- <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<[
3511
- E,
3512
- E2
3513
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3514
- E,
3515
- E2,
3516
- E3
3517
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3518
- E,
3519
- E2,
3520
- E3,
3521
- E4
3522
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3523
- E,
3524
- E2,
3525
- E3,
3526
- E4,
3527
- E5
3528
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3529
- E,
3530
- E2,
3531
- E3,
3532
- E4,
3533
- E5,
3534
- E6
3535
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3536
- E,
3537
- E2,
3538
- E3,
3539
- E4,
3540
- E5,
3541
- E6,
3542
- E7
3543
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3544
- E,
3545
- E2,
3546
- E3,
3547
- E4,
3548
- E5,
3549
- E6,
3550
- E7,
3551
- E8
3552
- ]>, E10 extends Env = IntersectNonAnyTypes<[
3553
- E,
3554
- E2,
3555
- E3,
3556
- E4,
3557
- E5,
3558
- E6,
3559
- E7,
3560
- E8,
3561
- E9
3562
- ]>>(method: M, path: P, ...handlers: [
2124
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
2125
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(method: M, path: P, ...handlers: [
3563
2126
  H<E2, MergedPath, I>,
3564
2127
  H<E3, MergedPath, I2>,
3565
2128
  H<E4, MergedPath, I3>,
@@ -3569,82 +2132,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3569
2132
  H<E8, MergedPath, I7>,
3570
2133
  H<E9, MergedPath, I8>,
3571
2134
  H<E10, MergedPath, I9, R>
3572
- ]): Hono<IntersectNonAnyTypes<[
3573
- E,
3574
- E2,
3575
- E3,
3576
- E4,
3577
- E5,
3578
- E6,
3579
- E7,
3580
- E8,
3581
- E9,
3582
- E10
3583
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
3584
- <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<[
3585
- E,
3586
- E2
3587
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3588
- E,
3589
- E2,
3590
- E3
3591
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3592
- E,
3593
- E2,
3594
- E3,
3595
- E4
3596
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3597
- E,
3598
- E2,
3599
- E3,
3600
- E4,
3601
- E5
3602
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3603
- E,
3604
- E2,
3605
- E3,
3606
- E4,
3607
- E5,
3608
- E6
3609
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3610
- E,
3611
- E2,
3612
- E3,
3613
- E4,
3614
- E5,
3615
- E6,
3616
- E7
3617
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3618
- E,
3619
- E2,
3620
- E3,
3621
- E4,
3622
- E5,
3623
- E6,
3624
- E7,
3625
- E8
3626
- ]>, E10 extends Env = IntersectNonAnyTypes<[
3627
- E,
3628
- E2,
3629
- E3,
3630
- E4,
3631
- E5,
3632
- E6,
3633
- E7,
3634
- E8,
3635
- E9
3636
- ]>, E11 extends Env = IntersectNonAnyTypes<[
3637
- E,
3638
- E2,
3639
- E3,
3640
- E4,
3641
- E5,
3642
- E6,
3643
- E7,
3644
- E8,
3645
- E9,
3646
- E10
3647
- ]>>(method: M, path: P, ...handlers: [
2135
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
2136
+ <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(method: M, path: P, ...handlers: [
3648
2137
  H<E2, MergedPath, I>,
3649
2138
  H<E3, MergedPath, I2>,
3650
2139
  H<E4, MergedPath, I3>,
@@ -3655,183 +2144,33 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3655
2144
  H<E9, MergedPath, I8>,
3656
2145
  H<E10, MergedPath, I9>,
3657
2146
  H<E11, MergedPath, I10, R>
3658
- ]): Hono<IntersectNonAnyTypes<[
3659
- E,
3660
- E2,
3661
- E3,
3662
- E4,
3663
- E5,
3664
- E6,
3665
- E7,
3666
- E8,
3667
- E9,
3668
- E10,
3669
- E11
3670
- ]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
2147
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
3671
2148
  <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>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
3672
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[
3673
- E,
3674
- E2
3675
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
3676
- <Ms 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<[
3677
- E,
3678
- E2
3679
- ]>>(methods: Ms, path: P, ...handlers: [
3680
- H<E2, MergedPath, I>,
3681
- H<E3, MergedPath, I2, R>
3682
- ]): Hono<IntersectNonAnyTypes<[
3683
- E,
3684
- E2,
3685
- E3
3686
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
3687
- <Ms 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<[
3688
- E,
3689
- E2
3690
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3691
- E,
3692
- E2,
3693
- E3
3694
- ]>>(methods: Ms, path: P, ...handlers: [
3695
- H<E2, MergedPath, I>,
3696
- H<E3, MergedPath, I2>,
3697
- H<E4, MergedPath, I3, R>
3698
- ]): Hono<IntersectNonAnyTypes<[
3699
- E,
3700
- E2,
3701
- E3,
3702
- E4
3703
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
3704
- <Ms 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<[
3705
- E,
3706
- E2
3707
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3708
- E,
3709
- E2,
3710
- E3
3711
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3712
- E,
3713
- E2,
3714
- E3,
3715
- E4
3716
- ]>>(methods: Ms, path: P, ...handlers: [
2149
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
2150
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
2151
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
2152
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(methods: Ms, path: P, ...handlers: [
3717
2153
  H<E2, MergedPath, I>,
3718
2154
  H<E3, MergedPath, I2>,
3719
2155
  H<E4, MergedPath, I3>,
3720
2156
  H<E5, MergedPath, I4, R>
3721
- ]): Hono<IntersectNonAnyTypes<[
3722
- E,
3723
- E2,
3724
- E3,
3725
- E4,
3726
- E5
3727
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
3728
- <Ms 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<[
3729
- E,
3730
- E2
3731
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3732
- E,
3733
- E2,
3734
- E3
3735
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3736
- E,
3737
- E2,
3738
- E3,
3739
- E4
3740
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3741
- E,
3742
- E2,
3743
- E3,
3744
- E4,
3745
- E5
3746
- ]>>(methods: Ms, path: P, ...handlers: [
2157
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
2158
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(methods: Ms, path: P, ...handlers: [
3747
2159
  H<E2, MergedPath, I>,
3748
2160
  H<E3, MergedPath, I2>,
3749
2161
  H<E4, MergedPath, I3>,
3750
2162
  H<E5, MergedPath, I4>,
3751
2163
  H<E6, MergedPath, I5, R>
3752
- ]): Hono<IntersectNonAnyTypes<[
3753
- E,
3754
- E2,
3755
- E3,
3756
- E4,
3757
- E5,
3758
- E6
3759
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
3760
- <Ms 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<[
3761
- E,
3762
- E2
3763
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3764
- E,
3765
- E2,
3766
- E3
3767
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3768
- E,
3769
- E2,
3770
- E3,
3771
- E4
3772
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3773
- E,
3774
- E2,
3775
- E3,
3776
- E4,
3777
- E5
3778
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3779
- E,
3780
- E2,
3781
- E3,
3782
- E4,
3783
- E5,
3784
- E6
3785
- ]>>(methods: Ms, path: P, ...handlers: [
2164
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
2165
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(methods: Ms, path: P, ...handlers: [
3786
2166
  H<E2, MergedPath, I>,
3787
2167
  H<E3, MergedPath, I2>,
3788
2168
  H<E4, MergedPath, I3>,
3789
2169
  H<E5, MergedPath, I4>,
3790
2170
  H<E6, MergedPath, I5>,
3791
2171
  H<E7, MergedPath, I6, R>
3792
- ]): Hono<IntersectNonAnyTypes<[
3793
- E,
3794
- E2,
3795
- E3,
3796
- E4,
3797
- E5,
3798
- E6,
3799
- E7
3800
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
3801
- <Ms 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<[
3802
- E,
3803
- E2
3804
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3805
- E,
3806
- E2,
3807
- E3
3808
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3809
- E,
3810
- E2,
3811
- E3,
3812
- E4
3813
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3814
- E,
3815
- E2,
3816
- E3,
3817
- E4,
3818
- E5
3819
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3820
- E,
3821
- E2,
3822
- E3,
3823
- E4,
3824
- E5,
3825
- E6
3826
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3827
- E,
3828
- E2,
3829
- E3,
3830
- E4,
3831
- E5,
3832
- E6,
3833
- E7
3834
- ]>>(methods: Ms, path: P, ...handlers: [
2172
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
2173
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(methods: Ms, path: P, ...handlers: [
3835
2174
  H<E2, MergedPath, I>,
3836
2175
  H<E3, MergedPath, I2>,
3837
2176
  H<E4, MergedPath, I3>,
@@ -3839,59 +2178,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3839
2178
  H<E6, MergedPath, I5>,
3840
2179
  H<E7, MergedPath, I6>,
3841
2180
  H<E8, MergedPath, I7, R>
3842
- ]): Hono<IntersectNonAnyTypes<[
3843
- E,
3844
- E2,
3845
- E3,
3846
- E4,
3847
- E5,
3848
- E6,
3849
- E7,
3850
- E8
3851
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
3852
- <Ms 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<[
3853
- E,
3854
- E2
3855
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3856
- E,
3857
- E2,
3858
- E3
3859
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3860
- E,
3861
- E2,
3862
- E3,
3863
- E4
3864
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3865
- E,
3866
- E2,
3867
- E3,
3868
- E4,
3869
- E5
3870
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3871
- E,
3872
- E2,
3873
- E3,
3874
- E4,
3875
- E5,
3876
- E6
3877
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3878
- E,
3879
- E2,
3880
- E3,
3881
- E4,
3882
- E5,
3883
- E6,
3884
- E7
3885
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3886
- E,
3887
- E2,
3888
- E3,
3889
- E4,
3890
- E5,
3891
- E6,
3892
- E7,
3893
- E8
3894
- ]>>(methods: Ms, path: P, ...handlers: [
2181
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
2182
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(methods: Ms, path: P, ...handlers: [
3895
2183
  H<E2, MergedPath, I>,
3896
2184
  H<E3, MergedPath, I2>,
3897
2185
  H<E4, MergedPath, I3>,
@@ -3900,70 +2188,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3900
2188
  H<E7, MergedPath, I6>,
3901
2189
  H<E8, MergedPath, I7>,
3902
2190
  H<E9, MergedPath, I8, R>
3903
- ]): Hono<IntersectNonAnyTypes<[
3904
- E,
3905
- E2,
3906
- E3,
3907
- E4,
3908
- E5,
3909
- E6,
3910
- E7,
3911
- E8,
3912
- E9
3913
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
3914
- <Ms 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<[
3915
- E,
3916
- E2
3917
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3918
- E,
3919
- E2,
3920
- E3
3921
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3922
- E,
3923
- E2,
3924
- E3,
3925
- E4
3926
- ]>, E6 extends Env = IntersectNonAnyTypes<[
3927
- E,
3928
- E2,
3929
- E3,
3930
- E4,
3931
- E5
3932
- ]>, E7 extends Env = IntersectNonAnyTypes<[
3933
- E,
3934
- E2,
3935
- E3,
3936
- E4,
3937
- E5,
3938
- E6
3939
- ]>, E8 extends Env = IntersectNonAnyTypes<[
3940
- E,
3941
- E2,
3942
- E3,
3943
- E4,
3944
- E5,
3945
- E6,
3946
- E7
3947
- ]>, E9 extends Env = IntersectNonAnyTypes<[
3948
- E,
3949
- E2,
3950
- E3,
3951
- E4,
3952
- E5,
3953
- E6,
3954
- E7,
3955
- E8
3956
- ]>, E10 extends Env = IntersectNonAnyTypes<[
3957
- E,
3958
- E2,
3959
- E3,
3960
- E4,
3961
- E5,
3962
- E6,
3963
- E7,
3964
- E8,
3965
- E9
3966
- ]>>(methods: Ms, path: P, ...handlers: [
2191
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
2192
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(methods: Ms, path: P, ...handlers: [
3967
2193
  H<E2, MergedPath, I>,
3968
2194
  H<E3, MergedPath, I2>,
3969
2195
  H<E4, MergedPath, I3>,
@@ -3973,82 +2199,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3973
2199
  H<E8, MergedPath, I7>,
3974
2200
  H<E9, MergedPath, I8>,
3975
2201
  H<E10, MergedPath, I9, R>
3976
- ]): Hono<IntersectNonAnyTypes<[
3977
- E,
3978
- E2,
3979
- E3,
3980
- E4,
3981
- E5,
3982
- E6,
3983
- E7,
3984
- E8,
3985
- E9,
3986
- E10
3987
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
3988
- <Ms 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<[
3989
- E,
3990
- E2
3991
- ]>, E4 extends Env = IntersectNonAnyTypes<[
3992
- E,
3993
- E2,
3994
- E3
3995
- ]>, E5 extends Env = IntersectNonAnyTypes<[
3996
- E,
3997
- E2,
3998
- E3,
3999
- E4
4000
- ]>, E6 extends Env = IntersectNonAnyTypes<[
4001
- E,
4002
- E2,
4003
- E3,
4004
- E4,
4005
- E5
4006
- ]>, E7 extends Env = IntersectNonAnyTypes<[
4007
- E,
4008
- E2,
4009
- E3,
4010
- E4,
4011
- E5,
4012
- E6
4013
- ]>, E8 extends Env = IntersectNonAnyTypes<[
4014
- E,
4015
- E2,
4016
- E3,
4017
- E4,
4018
- E5,
4019
- E6,
4020
- E7
4021
- ]>, E9 extends Env = IntersectNonAnyTypes<[
4022
- E,
4023
- E2,
4024
- E3,
4025
- E4,
4026
- E5,
4027
- E6,
4028
- E7,
4029
- E8
4030
- ]>, E10 extends Env = IntersectNonAnyTypes<[
4031
- E,
4032
- E2,
4033
- E3,
4034
- E4,
4035
- E5,
4036
- E6,
4037
- E7,
4038
- E8,
4039
- E9
4040
- ]>, E11 extends Env = IntersectNonAnyTypes<[
4041
- E,
4042
- E2,
4043
- E3,
4044
- E4,
4045
- E5,
4046
- E6,
4047
- E7,
4048
- E8,
4049
- E9,
4050
- E10
4051
- ]>>(methods: Ms, path: P, ...handlers: [
2202
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
2203
+ <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(methods: Ms, path: P, ...handlers: [
4052
2204
  H<E2, MergedPath, I>,
4053
2205
  H<E3, MergedPath, I2>,
4054
2206
  H<E4, MergedPath, I3>,
@@ -4059,19 +2211,7 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
4059
2211
  H<E9, MergedPath, I8>,
4060
2212
  H<E10, MergedPath, I9>,
4061
2213
  H<E11, MergedPath, I10, R>
4062
- ]): Hono<IntersectNonAnyTypes<[
4063
- E,
4064
- E2,
4065
- E3,
4066
- E4,
4067
- E5,
4068
- E6,
4069
- E7,
4070
- E8,
4071
- E9,
4072
- E10,
4073
- E11
4074
- ]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
2214
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
4075
2215
  <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
4076
2216
  <I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(methods: string | string[], paths: string[], ...handlers: H<E2, any, I, R>[]): Hono<E, S & ToSchema<string, string, I, MergeTypedResponse<R>>, BasePath>;
4077
2217
  }
@@ -4236,12 +2376,7 @@ declare type ProcessHead<T> = IfAnyThenEmptyObject<T extends Env ? (Env extends
4236
2376
  /**
4237
2377
  * Extracts the props for the renderer.
4238
2378
  */
4239
- declare type PropsForRenderer = [
4240
- ...Required<Parameters<Renderer>>
4241
- ] extends [
4242
- unknown,
4243
- infer Props
4244
- ] ? Props : unknown;
2379
+ declare type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
4245
2380
 
4246
2381
  declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver';
4247
2382
 
@@ -4414,7 +2549,7 @@ declare type Renderer = ContextRenderer extends Function ? ContextRenderer : Def
4414
2549
  * @module
4415
2550
  * HTTP Headers utility.
4416
2551
  */
4417
- declare 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";
2552
+ declare 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';
4418
2553
 
4419
2554
  /**
4420
2555
  * Resource limits defined for the user.
@@ -4438,12 +2573,9 @@ declare type ResourceLimits = {
4438
2573
 
4439
2574
  declare type ResponseFormat = KnownResponseFormat | string;
4440
2575
 
4441
- declare 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";
2576
+ declare 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';
4442
2577
 
4443
- declare type ResponseHeadersInit = [
4444
- string,
4445
- string
4446
- ][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
2578
+ declare type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
4447
2579
 
4448
2580
  declare interface ResponseInit_2<T extends StatusCode = StatusCode> {
4449
2581
  headers?: ResponseHeadersInit;
@@ -4485,18 +2617,7 @@ declare type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit_2<
4485
2617
  * ]
4486
2618
  * ```
4487
2619
  */
4488
- declare type Result<T> = [
4489
- [
4490
- T,
4491
- ParamIndexMap
4492
- ][],
4493
- ParamStash
4494
- ] | [
4495
- [
4496
- T,
4497
- Params
4498
- ][]
4499
- ];
2620
+ declare type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
4500
2621
 
4501
2622
  declare type ResultNode = {
4502
2623
  type: 'affectedRows';
@@ -4576,12 +2697,12 @@ declare type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 5
4576
2697
  * @template E - Environment type.
4577
2698
  */
4578
2699
  declare interface Set_2<E extends Env> {
4579
- <Key extends keyof E["Variables"]>(key: Key, value: E["Variables"][Key]): void;
2700
+ <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
4580
2701
  <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
4581
2702
  }
4582
2703
 
4583
2704
  declare interface SetHeaders {
4584
- (name: "Content-Type", value?: BaseMime, options?: SetHeadersOptions): void;
2705
+ (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
4585
2706
  (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
4586
2707
  (name: string, value?: string, options?: SetHeadersOptions): void;
4587
2708
  }
@@ -4602,13 +2723,6 @@ declare type SimplifyBodyData<T> = {
4602
2723
  [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;
4603
2724
  } & {};
4604
2725
 
4605
- /**
4606
- * A simple extension of Simplify that will deeply traverse array elements.
4607
- */
4608
- declare type SimplifyDeepArray<T> = T extends any[] ? {
4609
- [E in keyof T]: SimplifyDeepArray<T[E]>;
4610
- } : Simplify<T>;
4611
-
4612
2726
  /**
4613
2727
  * An interface that represents a span. A span represents a single operation
4614
2728
  * within a trace. Examples of span might include remote procedure calls or a
@@ -4942,8 +3056,8 @@ export { Temporal }
4942
3056
  * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
4943
3057
  */
4944
3058
  declare interface TextRespond {
4945
- <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, "text">;
4946
- <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, "text">;
3059
+ <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
3060
+ <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
4947
3061
  }
4948
3062
 
4949
3063
  /**
@@ -4953,7 +3067,7 @@ declare interface TextRespond {
4953
3067
  */
4954
3068
  declare type TimeInput = HrTime | number | Date;
4955
3069
 
4956
- declare type ToSchema<M extends string, P extends string, I extends Input | Input["in"], RorO> = Simplify<{
3070
+ declare type ToSchema<M extends string, P extends string, I extends Input | Input['in'], RorO> = Simplify<{
4957
3071
  [K in P]: {
4958
3072
  [K2 in M as AddDollar<K2>]: Simplify<{
4959
3073
  input: AddParam<ExtractInput<I>, P>;
@@ -4965,13 +3079,13 @@ declare type ToSchema<M extends string, P extends string, I extends Input | Inpu
4965
3079
  output: unknown extends T ? {} : T;
4966
3080
  outputFormat: I extends {
4967
3081
  outputFormat: string;
4968
- } ? I["outputFormat"] : F;
3082
+ } ? I['outputFormat'] : F;
4969
3083
  status: U;
4970
3084
  } : {
4971
3085
  output: unknown extends RorO ? {} : RorO;
4972
- outputFormat: unknown extends RorO ? "json" : I extends {
3086
+ outputFormat: unknown extends RorO ? 'json' : I extends {
4973
3087
  outputFormat: string;
4974
- } ? I["outputFormat"] : "json";
3088
+ } ? I['outputFormat'] : 'json';
4975
3089
  status: StatusCode;
4976
3090
  })>;
4977
3091
  };
@@ -5165,7 +3279,7 @@ declare type TransactionOptions_2 = {
5165
3279
  isolationLevel?: IsolationLevel;
5166
3280
  };
5167
3281
 
5168
- declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? "text" : T extends JSONValue ? "json" : ResponseFormat> = {
3282
+ declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat> = {
5169
3283
  _data: T;
5170
3284
  _status: U;
5171
3285
  _format: F;