@prisma/query-plan-executor 7.1.0-dev.2 → 7.1.0-dev.4

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 +284 -2178
  2. package/dist/index.js +221 -216
  3. package/package.json +7 -7
package/dist/index.d.ts CHANGED
@@ -141,8 +141,8 @@ declare const _baseMimes: {
141
141
  readonly xhtml: "application/xhtml+xml";
142
142
  readonly xml: "application/xml";
143
143
  readonly zip: "application/zip";
144
- readonly "3gp": "video/3gpp";
145
- readonly "3g2": "video/3gpp2";
144
+ readonly '3gp': "video/3gpp";
145
+ readonly '3g2': "video/3gpp2";
146
146
  readonly gltf: "model/gltf+json";
147
147
  readonly glb: "model/gltf-binary";
148
148
  };
@@ -199,10 +199,10 @@ declare type BodyDataValueObject<T> = {
199
199
  * Interface for responding with a body.
200
200
  */
201
201
  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">;
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'>;
206
206
  }
207
207
 
208
208
  declare type ChangePathOfSchema<S extends Schema, Path extends string> = keyof S extends never ? {
@@ -290,6 +290,7 @@ declare interface Context {
290
290
  }
291
291
 
292
292
  declare class Context_2<E extends Env = any, P extends string = any, I extends Input = {}> {
293
+
293
294
  /**
294
295
  * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
295
296
  *
@@ -303,7 +304,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
303
304
  * })
304
305
  * ```
305
306
  */
306
- env: E["Bindings"];
307
+ env: E['Bindings'];
307
308
  finalized: boolean;
308
309
  /**
309
310
  * `.error` can get the error object from the middleware if the Handler throws an error.
@@ -331,7 +332,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
331
332
  /**
332
333
  * `.req` is the instance of {@link HonoRequest}.
333
334
  */
334
- get req(): HonoRequest<P, I["out"]>;
335
+ get req(): HonoRequest<P, I['out']>;
335
336
  /**
336
337
  * @see {@link https://hono.dev/docs/api/context#event}
337
338
  * The FetchEvent associated with the current request.
@@ -471,7 +472,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
471
472
  * const result = c.var.client.oneMethod()
472
473
  * ```
473
474
  */
474
- get var(): Readonly<ContextVariableMap & (IsAny<E["Variables"]> extends true ? Record<string, any> : E["Variables"])>;
475
+ get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
475
476
  newResponse: NewResponse;
476
477
  /**
477
478
  * `.body()` can return the HTTP response.
@@ -562,7 +563,7 @@ declare type ContextOptions<E extends Env> = {
562
563
  /**
563
564
  * Bindings for the environment.
564
565
  */
565
- env: E["Bindings"];
566
+ env: E['Bindings'];
566
567
  /**
567
568
  * Execution context for the request.
568
569
  */
@@ -571,10 +572,7 @@ declare type ContextOptions<E extends Env> = {
571
572
  * Handler for not found responses.
572
573
  */
573
574
  notFoundHandler?: NotFoundHandler<E>;
574
- matchResult?: Result<[
575
- H,
576
- RouterRoute
577
- ]>;
575
+ matchResult?: Result<[H, RouterRoute]>;
578
576
  path?: string;
579
577
  };
580
578
 
@@ -652,7 +650,9 @@ params: Record<string, unknown>;
652
650
  model?: string | undefined;
653
651
  };
654
652
  };
655
- output: never;
653
+ output: {
654
+ data: JSONValue;
655
+ };
656
656
  outputFormat: "json";
657
657
  status: ContentfulStatusCode;
658
658
  };
@@ -689,7 +689,9 @@ param: {
689
689
  txId: string;
690
690
  };
691
691
  };
692
- output: never;
692
+ output: {
693
+ data: JSONValue;
694
+ };
693
695
  outputFormat: "json";
694
696
  status: ContentfulStatusCode;
695
697
  };
@@ -881,7 +883,9 @@ declare type ExtendedSpanOptions_2 = SpanOptions & {
881
883
  name: string;
882
884
  };
883
885
 
884
- declare type ExtractInput<I extends Input | Input["in"]> = I extends Input ? unknown extends I["in"] ? {} : I["in"] : I;
886
+ 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;
887
+
888
+ declare type ExtractInput<I extends Input | Input['in']> = I extends Input ? unknown extends I['in'] ? {} : I['in'] : I;
885
889
 
886
890
  declare type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
887
891
  [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
@@ -963,752 +967,148 @@ declare type Fragment = {
963
967
  * @template E - Environment type.
964
968
  */
965
969
  declare interface Get<E extends Env> {
966
- <Key extends keyof E["Variables"]>(key: Key): E["Variables"][Key];
970
+ <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
967
971
  <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
968
972
  }
969
973
 
970
974
  declare const GET_MATCH_RESULT: symbol;
971
975
 
972
976
  declare type GetPath<E extends Env> = (request: Request, options?: {
973
- env?: E["Bindings"];
977
+ env?: E['Bindings'];
974
978
  }) => string;
975
979
 
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>;
980
+ 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
981
 
978
982
  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
983
 
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>;
984
+ declare interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/'> {
985
+ <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>;
986
+ <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
987
  <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>,
988
+ <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>;
989
+ <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>;
990
+ <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>;
991
+ <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>;
992
+ <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: [
993
+ H<E2, P, I> & M1,
994
+ H<E3, P, I2> & M2,
995
+ H<E4, P, I3> & M3,
996
+ H<E5, P, I4> & M4,
1080
997
  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>,
998
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, 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, 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: [
1000
+ H<E2, MergedPath, I> & M1,
1001
+ H<E3, MergedPath, I2> & M2,
1002
+ H<E4, MergedPath, I3> & M3,
1105
1003
  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>,
1004
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
1005
+ <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: [
1006
+ H<E2, P, I> & M1,
1007
+ H<E3, P, I2> & M2,
1008
+ H<E4, P, I3> & M3,
1009
+ H<E5, P, I4> & M4,
1010
+ H<E6, P, I5> & M5,
1138
1011
  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>,
1012
+ ]): 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>;
1013
+ <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: [
1014
+ H<E2, MergedPath, I> & M1,
1015
+ H<E3, MergedPath, I2> & M2,
1016
+ H<E4, MergedPath, I3> & M3,
1017
+ H<E5, MergedPath, I4> & M4,
1171
1018
  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>,
1019
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
1020
+ <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: [
1021
+ H<E2, P, I> & M1,
1022
+ H<E3, P, I2> & M2,
1023
+ H<E4, P, I3> & M3,
1024
+ H<E5, P, I4> & M4,
1025
+ H<E6, P, I5> & M5,
1026
+ H<E7, P, I6> & M6,
1213
1027
  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>,
1028
+ ]): 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>;
1029
+ <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: [
1030
+ H<E2, MergedPath, I> & M1,
1031
+ H<E3, MergedPath, I2> & M2,
1032
+ H<E4, MergedPath, I3> & M3,
1033
+ H<E5, MergedPath, I4> & M4,
1034
+ H<E6, MergedPath, I5> & M5,
1255
1035
  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>,
1036
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath>;
1037
+ <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: [
1038
+ H<E2, P, I> & M1,
1039
+ H<E3, P, I2> & M2,
1040
+ H<E4, P, I3> & M3,
1041
+ H<E5, P, I4> & M4,
1042
+ H<E6, P, I5> & M5,
1043
+ H<E7, P, I6> & M6,
1044
+ H<E8, P, I7> & M7,
1307
1045
  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>,
1046
+ ]): 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>;
1047
+ <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: [
1048
+ H<E2, MergedPath, I> & M1,
1049
+ H<E3, MergedPath, I2> & M2,
1050
+ H<E4, MergedPath, I3> & M3,
1051
+ H<E5, MergedPath, I4> & M4,
1052
+ H<E6, MergedPath, I5> & M5,
1053
+ H<E7, MergedPath, I6> & M6,
1359
1054
  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>,
1055
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath>;
1056
+ <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: [
1057
+ H<E2, P, I> & M1,
1058
+ H<E3, P, I2> & M2,
1059
+ H<E4, P, I3> & M3,
1060
+ H<E5, P, I4> & M4,
1061
+ H<E6, P, I5> & M5,
1062
+ H<E7, P, I6> & M6,
1063
+ H<E8, P, I7> & M7,
1064
+ H<E9, P, I8> & M8,
1422
1065
  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>,
1066
+ ]): 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>;
1067
+ <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: [
1068
+ H<E2, MergedPath, I> & M1,
1069
+ H<E3, MergedPath, I2> & M2,
1070
+ H<E4, MergedPath, I3> & M3,
1071
+ H<E5, MergedPath, I4> & M4,
1072
+ H<E6, MergedPath, I5> & M5,
1073
+ H<E7, MergedPath, I6> & M6,
1074
+ H<E8, MergedPath, I7> & M7,
1485
1075
  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>,
1076
+ ]): 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>;
1077
+ <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: [
1078
+ H<E2, P, I> & M1,
1079
+ H<E3, P, I2> & M2,
1080
+ H<E4, P, I3> & M3,
1081
+ H<E5, P, I4> & M4,
1082
+ H<E6, P, I5> & M5,
1083
+ H<E7, P, I6> & M6,
1084
+ H<E8, P, I7> & M7,
1085
+ H<E9, P, I8> & M8,
1086
+ H<E10, P, I9> & M9,
1560
1087
  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>,
1088
+ ]): 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>;
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, 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: [
1090
+ H<E2, MergedPath, I> & M1,
1091
+ H<E3, MergedPath, I2> & M2,
1092
+ H<E4, MergedPath, I3> & M3,
1093
+ H<E5, MergedPath, I4> & M4,
1094
+ H<E6, MergedPath, I5> & M5,
1095
+ H<E7, MergedPath, I6> & M6,
1096
+ H<E8, MergedPath, I7> & M7,
1097
+ H<E9, MergedPath, I8> & M8,
1635
1098
  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>,
1099
+ ]): 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>;
1100
+ <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: [
1101
+ H<E2, MergedPath, I> & M1,
1102
+ H<E3, MergedPath, I2> & M2,
1103
+ H<E4, MergedPath, I3> & M3,
1104
+ H<E5, MergedPath, I4> & M4,
1105
+ H<E6, MergedPath, I5> & M5,
1106
+ H<E7, MergedPath, I6> & M6,
1107
+ H<E8, MergedPath, I7> & M7,
1108
+ H<E9, MergedPath, I8> & M8,
1109
+ H<E10, MergedPath, I9> & M9,
1710
1110
  H<E11, MergedPath, I10, R>
1711
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
1111
+ ]): 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
1112
  <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
1113
  <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
1114
  <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 +1116,25 @@ declare interface HandlerInterface<E extends Env = Env, M extends string = strin
1716
1116
 
1717
1117
  declare type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
1718
1118
 
1719
- declare type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
1119
+ declare type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
1720
1120
 
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>;
1121
+ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
1122
+
1123
+ get: HandlerInterface<E, 'get', S, BasePath>;
1124
+ post: HandlerInterface<E, 'post', S, BasePath>;
1125
+ put: HandlerInterface<E, 'put', S, BasePath>;
1126
+ delete: HandlerInterface<E, 'delete', S, BasePath>;
1127
+ options: HandlerInterface<E, 'options', S, BasePath>;
1128
+ patch: HandlerInterface<E, 'patch', S, BasePath>;
1129
+ all: HandlerInterface<E, 'all', S, BasePath>;
1729
1130
  on: OnHandlerInterface<E, S, BasePath>;
1730
1131
  use: MiddlewareHandlerInterface<E, S, BasePath>;
1731
- router: Router<[
1732
- H,
1733
- RouterRoute
1734
- ]>;
1132
+ router: Router<[H, RouterRoute]>;
1735
1133
  readonly getPath: GetPath<E>;
1134
+ private _basePath;
1736
1135
  routes: RouterRoute[];
1737
1136
  constructor(options?: HonoOptions<E>);
1137
+ private errorHandler;
1738
1138
  /**
1739
1139
  * `.route()` allows grouping other Hono instance in routes.
1740
1140
  *
@@ -1845,7 +1245,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
1845
1245
  * @returns {Response | Promise<Response>} response of request
1846
1246
  *
1847
1247
  */
1848
- fetch: (request: Request, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1248
+ fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1849
1249
  /**
1850
1250
  * `.request()` is a useful method for testing.
1851
1251
  * You can pass a URL or pathname to send a GET request.
@@ -1898,10 +1298,7 @@ declare type HonoOptions<E extends Env> = {
1898
1298
  * const app = new Hono({ router: new RegExpRouter() })
1899
1299
  * ```
1900
1300
  */
1901
- router?: Router<[
1902
- H,
1903
- RouterRoute
1904
- ]>;
1301
+ router?: Router<[H, RouterRoute]>;
1905
1302
  /**
1906
1303
  * `getPath` can handle the host header value.
1907
1304
  *
@@ -1925,11 +1322,9 @@ declare type HonoOptions<E extends Env> = {
1925
1322
  getPath?: GetPath<E>;
1926
1323
  };
1927
1324
 
1928
- declare class HonoRequest<P extends string = "/", I extends Input["out"] = {}> {
1929
- [GET_MATCH_RESULT]: Result<[
1930
- unknown,
1931
- RouterRoute
1932
- ]>;
1325
+ declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
1326
+
1327
+ [GET_MATCH_RESULT]: Result<[unknown, RouterRoute]>;
1933
1328
  /**
1934
1329
  * `.raw` can get the raw Request object.
1935
1330
  *
@@ -1960,10 +1355,7 @@ declare class HonoRequest<P extends string = "/", I extends Input["out"] = {}> {
1960
1355
  */
1961
1356
  path: string;
1962
1357
  bodyCache: BodyCache;
1963
- constructor(request: Request, path?: string, matchResult?: Result<[
1964
- unknown,
1965
- RouterRoute
1966
- ]>);
1358
+ constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
1967
1359
  /**
1968
1360
  * `.req.param()` gets the path parameters.
1969
1361
  *
@@ -2261,14 +1653,11 @@ declare type Input = {
2261
1653
  outputFormat?: ResponseFormat;
2262
1654
  };
2263
1655
 
2264
- declare type InputToDataByTarget<T extends Input["out"], Target extends keyof ValidationTargets> = T extends {
1656
+ declare type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends {
2265
1657
  [K in Target]: infer R;
2266
1658
  } ? R : never;
2267
1659
 
2268
- declare type IntersectNonAnyTypes<T extends any[]> = T extends [
2269
- infer Head,
2270
- ...infer Rest
2271
- ] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
1660
+ declare type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
2272
1661
 
2273
1662
  declare type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
2274
1663
 
@@ -2293,15 +1682,28 @@ declare type JSONObject = {
2293
1682
  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
2294
1683
  };
2295
1684
 
2296
- declare type JSONParsed<T> = T extends {
1685
+ /**
1686
+ * Convert a type to a JSON-compatible type.
1687
+ *
1688
+ * Non-JSON values such as `Date` implement `.toJSON()`,
1689
+ * so they can be transformed to a value assignable to `JSONObject`
1690
+ *
1691
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
1692
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
1693
+ *
1694
+ * This behaviour can be controlled by the `TError` generic type parameter,
1695
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
1696
+ * You can set it to `never` to disable this check.
1697
+ */
1698
+ declare type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
2297
1699
  toJSON(): infer J;
2298
1700
  } ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
2299
1701
  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;
1702
+ } ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
1703
+ [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
1704
+ } : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
1705
+ [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>;
1706
+ } : T extends unknown ? T extends TError ? never : JSONValue : never;
2305
1707
 
2306
1708
  declare type JSONPrimitive = string | boolean | number | null;
2307
1709
 
@@ -2319,21 +1721,21 @@ declare type JSONPrimitive = string | boolean | number | null;
2319
1721
  * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
2320
1722
  */
2321
1723
  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>;
1724
+ <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
1725
+ <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
2324
1726
  }
2325
1727
 
2326
1728
  /**
2327
1729
  * @template T - The type of the JSON value or simplified unknown type.
2328
1730
  * @template U - The type of the status code.
2329
1731
  *
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.
1732
+ * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
2331
1733
  */
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">;
1734
+ declare type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
2333
1735
 
2334
1736
  declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
2335
1737
 
2336
- declare type KnownResponseFormat = "json" | "text" | "redirect";
1738
+ declare type KnownResponseFormat = 'json' | 'text' | 'redirect';
2337
1739
 
2338
1740
  declare type Layout<T = Record<string, any>> = (props: T) => any;
2339
1741
 
@@ -2475,28 +1877,28 @@ declare interface LogSink {
2475
1877
  }
2476
1878
 
2477
1879
  declare type MergeEndpointParamsWithPath<T extends Endpoint, SubPath extends string> = T extends unknown ? {
2478
- input: T["input"] extends {
1880
+ input: T['input'] extends {
2479
1881
  param: infer _;
2480
- } ? ExtractParams<SubPath> extends never ? T["input"] : FlattenIfIntersect<T["input"] & {
1882
+ } ? ExtractParams<SubPath> extends never ? T['input'] : FlattenIfIntersect<T['input'] & {
2481
1883
  param: {
2482
1884
  [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
2483
1885
  };
2484
- }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T["input"] : T["input"] & {
1886
+ }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T['input'] : T['input'] & {
2485
1887
  param: {
2486
1888
  [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
2487
1889
  };
2488
1890
  };
2489
- output: T["output"];
2490
- outputFormat: T["outputFormat"];
2491
- status: T["status"];
1891
+ output: T['output'];
1892
+ outputFormat: T['outputFormat'];
1893
+ status: T['status'];
2492
1894
  } : never;
2493
1895
 
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}`;
1896
+ declare type MergeMiddlewareResponse<T> = MergeTypedResponseStrict<ExtractHandlerResponse<T>>;
1897
+
1898
+ 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
1899
 
2496
1900
  declare type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = {
2497
- [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [
2498
- OrigSchema[P]
2499
- ] extends [
1901
+ [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [OrigSchema[P]] extends [
2500
1902
  Record<string, Endpoint>
2501
1903
  ] ? {
2502
1904
  [M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath>;
@@ -2505,264 +1907,57 @@ declare type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string>
2505
1907
 
2506
1908
  declare type MergeTypedResponse<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;
2507
1909
 
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: [
1910
+ declare type MergeTypedResponseStrict<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : never : T extends TypedResponse ? T : never;
1911
+
1912
+ 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>;
1913
+
1914
+ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
1915
+ <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
1916
+ <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
1917
+ <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>;
1918
+ <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>;
1919
+ <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: [
1920
+ MiddlewareHandler<E2, P, any, any>,
1921
+ MiddlewareHandler<E3, P, any, any>,
1922
+ MiddlewareHandler<E4, P, any, any>
1923
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath>;
1924
+ <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>;
1925
+ <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
1926
  MiddlewareHandler<E2, P>,
2576
1927
  MiddlewareHandler<E3, P>,
2577
1928
  MiddlewareHandler<E4, P>,
2578
1929
  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: [
1930
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath>;
1931
+ <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>;
1932
+ <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
1933
  MiddlewareHandler<E2, P>,
2623
1934
  MiddlewareHandler<E3, P>,
2624
1935
  MiddlewareHandler<E4, P>,
2625
1936
  MiddlewareHandler<E5, P>,
2626
1937
  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: [
1938
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, 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]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
2648
1940
  MiddlewareHandler<E2, P>,
2649
1941
  MiddlewareHandler<E3, P>,
2650
1942
  MiddlewareHandler<E4, P>,
2651
1943
  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: [
1944
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1945
+ <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
1946
  MiddlewareHandler<E2, P>,
2686
1947
  MiddlewareHandler<E3, P>,
2687
1948
  MiddlewareHandler<E4, P>,
2688
1949
  MiddlewareHandler<E5, P>,
2689
1950
  MiddlewareHandler<E6, P>,
2690
1951
  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: [
1952
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath>;
1953
+ <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
1954
  MiddlewareHandler<E2, P>,
2720
1955
  MiddlewareHandler<E3, P>,
2721
1956
  MiddlewareHandler<E4, P>,
2722
1957
  MiddlewareHandler<E5, P>,
2723
1958
  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: [
1959
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1960
+ <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
1961
  MiddlewareHandler<E2, P>,
2767
1962
  MiddlewareHandler<E3, P>,
2768
1963
  MiddlewareHandler<E4, P>,
@@ -2770,100 +1965,16 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2770
1965
  MiddlewareHandler<E6, P>,
2771
1966
  MiddlewareHandler<E7, P>,
2772
1967
  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: [
1968
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath>;
1969
+ <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
1970
  MiddlewareHandler<E2, P>,
2810
1971
  MiddlewareHandler<E3, P>,
2811
1972
  MiddlewareHandler<E4, P>,
2812
1973
  MiddlewareHandler<E5, P>,
2813
1974
  MiddlewareHandler<E6, P>,
2814
1975
  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: [
1976
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1977
+ <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
1978
  MiddlewareHandler<E2, P>,
2868
1979
  MiddlewareHandler<E3, P>,
2869
1980
  MiddlewareHandler<E4, P>,
@@ -2872,51 +1983,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2872
1983
  MiddlewareHandler<E7, P>,
2873
1984
  MiddlewareHandler<E8, P>,
2874
1985
  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: [
1986
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath>;
1987
+ <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
1988
  MiddlewareHandler<E2, P>,
2921
1989
  MiddlewareHandler<E3, P>,
2922
1990
  MiddlewareHandler<E4, P>,
@@ -2924,69 +1992,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2924
1992
  MiddlewareHandler<E6, P>,
2925
1993
  MiddlewareHandler<E7, P>,
2926
1994
  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: [
1995
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1996
+ <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
1997
  MiddlewareHandler<E2, P>,
2991
1998
  MiddlewareHandler<E3, P>,
2992
1999
  MiddlewareHandler<E4, P>,
@@ -2996,61 +2003,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2996
2003
  MiddlewareHandler<E8, P>,
2997
2004
  MiddlewareHandler<E9, P>,
2998
2005
  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: [
2006
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath>;
2007
+ <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
2008
  MiddlewareHandler<E2, P>,
3055
2009
  MiddlewareHandler<E3, P>,
3056
2010
  MiddlewareHandler<E4, P>,
@@ -3059,81 +2013,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
3059
2013
  MiddlewareHandler<E7, P>,
3060
2014
  MiddlewareHandler<E8, P>,
3061
2015
  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: [
2016
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2017
+ <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
2018
  MiddlewareHandler<E2, P>,
3138
2019
  MiddlewareHandler<E3, P>,
3139
2020
  MiddlewareHandler<E4, P>,
@@ -3144,72 +2025,8 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
3144
2025
  MiddlewareHandler<E9, P>,
3145
2026
  MiddlewareHandler<E10, P>,
3146
2027
  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: [
2028
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath>;
2029
+ <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
2030
  MiddlewareHandler<E2, P>,
3214
2031
  MiddlewareHandler<E3, P>,
3215
2032
  MiddlewareHandler<E4, P>,
@@ -3219,18 +2036,7 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
3219
2036
  MiddlewareHandler<E8, P>,
3220
2037
  MiddlewareHandler<E9, P>,
3221
2038
  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>;
2039
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
3234
2040
  <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
3235
2041
  }
3236
2042
 
@@ -3264,170 +2070,32 @@ declare type OmitSymbolKeys<T> = {
3264
2070
  [K in keyof T as K extends symbol ? never : K]: T[K];
3265
2071
  };
3266
2072
 
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: [
2073
+ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
2074
+ <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>;
2075
+ <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>;
2076
+ <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>;
2077
+ <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
2078
  H<E2, MergedPath, I>,
3314
2079
  H<E3, MergedPath, I2>,
3315
2080
  H<E4, MergedPath, I3>,
3316
2081
  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: [
2082
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, 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, 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
2084
  H<E2, MergedPath, I>,
3344
2085
  H<E3, MergedPath, I2>,
3345
2086
  H<E4, MergedPath, I3>,
3346
2087
  H<E5, MergedPath, I4>,
3347
2088
  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: [
2089
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
2090
+ <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
2091
  H<E2, MergedPath, I>,
3383
2092
  H<E3, MergedPath, I2>,
3384
2093
  H<E4, MergedPath, I3>,
3385
2094
  H<E5, MergedPath, I4>,
3386
2095
  H<E6, MergedPath, I5>,
3387
2096
  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: [
2097
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, 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, 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
2099
  H<E2, MergedPath, I>,
3432
2100
  H<E3, MergedPath, I2>,
3433
2101
  H<E4, MergedPath, I3>,
@@ -3435,59 +2103,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3435
2103
  H<E6, MergedPath, I5>,
3436
2104
  H<E7, MergedPath, I6>,
3437
2105
  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: [
2106
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
2107
+ <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
2108
  H<E2, MergedPath, I>,
3492
2109
  H<E3, MergedPath, I2>,
3493
2110
  H<E4, MergedPath, I3>,
@@ -3496,70 +2113,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3496
2113
  H<E7, MergedPath, I6>,
3497
2114
  H<E8, MergedPath, I7>,
3498
2115
  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: [
2116
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
2117
+ <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
2118
  H<E2, MergedPath, I>,
3564
2119
  H<E3, MergedPath, I2>,
3565
2120
  H<E4, MergedPath, I3>,
@@ -3569,82 +2124,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3569
2124
  H<E8, MergedPath, I7>,
3570
2125
  H<E9, MergedPath, I8>,
3571
2126
  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: [
2127
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
2128
+ <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
2129
  H<E2, MergedPath, I>,
3649
2130
  H<E3, MergedPath, I2>,
3650
2131
  H<E4, MergedPath, I3>,
@@ -3655,183 +2136,33 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3655
2136
  H<E9, MergedPath, I8>,
3656
2137
  H<E10, MergedPath, I9>,
3657
2138
  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>;
2139
+ ]): 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
2140
  <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: [
2141
+ <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>;
2142
+ <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>;
2143
+ <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>;
2144
+ <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
2145
  H<E2, MergedPath, I>,
3718
2146
  H<E3, MergedPath, I2>,
3719
2147
  H<E4, MergedPath, I3>,
3720
2148
  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: [
2149
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4, 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, 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
2151
  H<E2, MergedPath, I>,
3748
2152
  H<E3, MergedPath, I2>,
3749
2153
  H<E4, MergedPath, I3>,
3750
2154
  H<E5, MergedPath, I4>,
3751
2155
  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: [
2156
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
2157
+ <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
2158
  H<E2, MergedPath, I>,
3787
2159
  H<E3, MergedPath, I2>,
3788
2160
  H<E4, MergedPath, I3>,
3789
2161
  H<E5, MergedPath, I4>,
3790
2162
  H<E6, MergedPath, I5>,
3791
2163
  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: [
2164
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6, 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, 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
2166
  H<E2, MergedPath, I>,
3836
2167
  H<E3, MergedPath, I2>,
3837
2168
  H<E4, MergedPath, I3>,
@@ -3839,59 +2170,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3839
2170
  H<E6, MergedPath, I5>,
3840
2171
  H<E7, MergedPath, I6>,
3841
2172
  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: [
2173
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
2174
+ <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
2175
  H<E2, MergedPath, I>,
3896
2176
  H<E3, MergedPath, I2>,
3897
2177
  H<E4, MergedPath, I3>,
@@ -3900,70 +2180,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3900
2180
  H<E7, MergedPath, I6>,
3901
2181
  H<E8, MergedPath, I7>,
3902
2182
  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: [
2183
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
2184
+ <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
2185
  H<E2, MergedPath, I>,
3968
2186
  H<E3, MergedPath, I2>,
3969
2187
  H<E4, MergedPath, I3>,
@@ -3973,82 +2191,8 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
3973
2191
  H<E8, MergedPath, I7>,
3974
2192
  H<E9, MergedPath, I8>,
3975
2193
  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: [
2194
+ ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
2195
+ <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
2196
  H<E2, MergedPath, I>,
4053
2197
  H<E3, MergedPath, I2>,
4054
2198
  H<E4, MergedPath, I3>,
@@ -4059,19 +2203,7 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
4059
2203
  H<E9, MergedPath, I8>,
4060
2204
  H<E10, MergedPath, I9>,
4061
2205
  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>;
2206
+ ]): 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
2207
  <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
2208
  <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
2209
  }
@@ -4236,12 +2368,7 @@ declare type ProcessHead<T> = IfAnyThenEmptyObject<T extends Env ? (Env extends
4236
2368
  /**
4237
2369
  * Extracts the props for the renderer.
4238
2370
  */
4239
- declare type PropsForRenderer = [
4240
- ...Required<Parameters<Renderer>>
4241
- ] extends [
4242
- unknown,
4243
- infer Props
4244
- ] ? Props : unknown;
2371
+ declare type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
4245
2372
 
4246
2373
  declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver';
4247
2374
 
@@ -4414,7 +2541,7 @@ declare type Renderer = ContextRenderer extends Function ? ContextRenderer : Def
4414
2541
  * @module
4415
2542
  * HTTP Headers utility.
4416
2543
  */
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";
2544
+ 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
2545
 
4419
2546
  /**
4420
2547
  * Resource limits defined for the user.
@@ -4438,12 +2565,9 @@ declare type ResourceLimits = {
4438
2565
 
4439
2566
  declare type ResponseFormat = KnownResponseFormat | string;
4440
2567
 
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";
2568
+ 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
2569
 
4443
- declare type ResponseHeadersInit = [
4444
- string,
4445
- string
4446
- ][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
2570
+ declare type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
4447
2571
 
4448
2572
  declare interface ResponseInit_2<T extends StatusCode = StatusCode> {
4449
2573
  headers?: ResponseHeadersInit;
@@ -4485,18 +2609,7 @@ declare type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit_2<
4485
2609
  * ]
4486
2610
  * ```
4487
2611
  */
4488
- declare type Result<T> = [
4489
- [
4490
- T,
4491
- ParamIndexMap
4492
- ][],
4493
- ParamStash
4494
- ] | [
4495
- [
4496
- T,
4497
- Params
4498
- ][]
4499
- ];
2612
+ declare type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
4500
2613
 
4501
2614
  declare type ResultNode = {
4502
2615
  type: 'affectedRows';
@@ -4576,12 +2689,12 @@ declare type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 5
4576
2689
  * @template E - Environment type.
4577
2690
  */
4578
2691
  declare interface Set_2<E extends Env> {
4579
- <Key extends keyof E["Variables"]>(key: Key, value: E["Variables"][Key]): void;
2692
+ <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
4580
2693
  <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
4581
2694
  }
4582
2695
 
4583
2696
  declare interface SetHeaders {
4584
- (name: "Content-Type", value?: BaseMime, options?: SetHeadersOptions): void;
2697
+ (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
4585
2698
  (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
4586
2699
  (name: string, value?: string, options?: SetHeadersOptions): void;
4587
2700
  }
@@ -4602,13 +2715,6 @@ declare type SimplifyBodyData<T> = {
4602
2715
  [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
2716
  } & {};
4604
2717
 
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
2718
  /**
4613
2719
  * An interface that represents a span. A span represents a single operation
4614
2720
  * within a trace. Examples of span might include remote procedure calls or a
@@ -4942,8 +3048,8 @@ export { Temporal }
4942
3048
  * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
4943
3049
  */
4944
3050
  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">;
3051
+ <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
3052
+ <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
4947
3053
  }
4948
3054
 
4949
3055
  /**
@@ -4953,7 +3059,7 @@ declare interface TextRespond {
4953
3059
  */
4954
3060
  declare type TimeInput = HrTime | number | Date;
4955
3061
 
4956
- declare type ToSchema<M extends string, P extends string, I extends Input | Input["in"], RorO> = Simplify<{
3062
+ declare type ToSchema<M extends string, P extends string, I extends Input | Input['in'], RorO> = Simplify<{
4957
3063
  [K in P]: {
4958
3064
  [K2 in M as AddDollar<K2>]: Simplify<{
4959
3065
  input: AddParam<ExtractInput<I>, P>;
@@ -4965,13 +3071,13 @@ declare type ToSchema<M extends string, P extends string, I extends Input | Inpu
4965
3071
  output: unknown extends T ? {} : T;
4966
3072
  outputFormat: I extends {
4967
3073
  outputFormat: string;
4968
- } ? I["outputFormat"] : F;
3074
+ } ? I['outputFormat'] : F;
4969
3075
  status: U;
4970
3076
  } : {
4971
3077
  output: unknown extends RorO ? {} : RorO;
4972
- outputFormat: unknown extends RorO ? "json" : I extends {
3078
+ outputFormat: unknown extends RorO ? 'json' : I extends {
4973
3079
  outputFormat: string;
4974
- } ? I["outputFormat"] : "json";
3080
+ } ? I['outputFormat'] : 'json';
4975
3081
  status: StatusCode;
4976
3082
  })>;
4977
3083
  };
@@ -5165,7 +3271,7 @@ declare type TransactionOptions_2 = {
5165
3271
  isolationLevel?: IsolationLevel;
5166
3272
  };
5167
3273
 
5168
- declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? "text" : T extends JSONValue ? "json" : ResponseFormat> = {
3274
+ declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat> = {
5169
3275
  _data: T;
5170
3276
  _status: U;
5171
3277
  _format: F;