@prisma/query-plan-executor 7.2.0 → 7.3.0-integration-prisma6-fix-cloudflare-engine.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.ts +2179 -293
  2. package/dist/index.js +990 -1479
  3. package/package.json +7 -7
package/dist/index.d.ts CHANGED
@@ -34,14 +34,8 @@ declare class App {
34
34
  shutdown(): Promise<void>;
35
35
  /**
36
36
  * Executes a query plan and returns the result.
37
- *
38
- * @param queryPlan - The query plan to execute
39
- * @param placeholderValues - Placeholder values for the query
40
- * @param comments - Pre-computed SQL commenter tags from the client
41
- * @param resourceLimits - Resource limits for the query
42
- * @param transactionId - Transaction ID if running within a transaction
43
37
  */
44
- query(queryPlan: QueryPlanNode, placeholderValues: Record<string, unknown>, comments: Record<string, string> | undefined, resourceLimits: ResourceLimits, transactionId: string | null): Promise<unknown>;
38
+ query(queryPlan: QueryPlanNode, placeholderValues: Record<string, unknown>, resourceLimits: ResourceLimits, transactionId: string | null): Promise<unknown>;
45
39
  /**
46
40
  * Starts a new transaction.
47
41
  */
@@ -147,8 +141,8 @@ declare const _baseMimes: {
147
141
  readonly xhtml: "application/xhtml+xml";
148
142
  readonly xml: "application/xml";
149
143
  readonly zip: "application/zip";
150
- readonly '3gp': "video/3gpp";
151
- readonly '3g2': "video/3gpp2";
144
+ readonly "3gp": "video/3gpp";
145
+ readonly "3g2": "video/3gpp2";
152
146
  readonly gltf: "model/gltf+json";
153
147
  readonly glb: "model/gltf-binary";
154
148
  };
@@ -205,10 +199,10 @@ declare type BodyDataValueObject<T> = {
205
199
  * Interface for responding with a body.
206
200
  */
207
201
  declare interface BodyRespond {
208
- <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'body'>;
209
- <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'body'>;
210
- <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
211
- <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
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">;
212
206
  }
213
207
 
214
208
  declare type ChangePathOfSchema<S extends Schema, Path extends string> = keyof S extends never ? {
@@ -296,7 +290,6 @@ declare interface Context {
296
290
  }
297
291
 
298
292
  declare class Context_2<E extends Env = any, P extends string = any, I extends Input = {}> {
299
-
300
293
  /**
301
294
  * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
302
295
  *
@@ -310,7 +303,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
310
303
  * })
311
304
  * ```
312
305
  */
313
- env: E['Bindings'];
306
+ env: E["Bindings"];
314
307
  finalized: boolean;
315
308
  /**
316
309
  * `.error` can get the error object from the middleware if the Handler throws an error.
@@ -338,7 +331,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
338
331
  /**
339
332
  * `.req` is the instance of {@link HonoRequest}.
340
333
  */
341
- get req(): HonoRequest<P, I['out']>;
334
+ get req(): HonoRequest<P, I["out"]>;
342
335
  /**
343
336
  * @see {@link https://hono.dev/docs/api/context#event}
344
337
  * The FetchEvent associated with the current request.
@@ -478,7 +471,7 @@ declare class Context_2<E extends Env = any, P extends string = any, I extends I
478
471
  * const result = c.var.client.oneMethod()
479
472
  * ```
480
473
  */
481
- get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
474
+ get var(): Readonly<ContextVariableMap & (IsAny<E["Variables"]> extends true ? Record<string, any> : E["Variables"])>;
482
475
  newResponse: NewResponse;
483
476
  /**
484
477
  * `.body()` can return the HTTP response.
@@ -569,7 +562,7 @@ declare type ContextOptions<E extends Env> = {
569
562
  /**
570
563
  * Bindings for the environment.
571
564
  */
572
- env: E['Bindings'];
565
+ env: E["Bindings"];
573
566
  /**
574
567
  * Execution context for the request.
575
568
  */
@@ -578,7 +571,10 @@ declare type ContextOptions<E extends Env> = {
578
571
  * Handler for not found responses.
579
572
  */
580
573
  notFoundHandler?: NotFoundHandler<E>;
581
- matchResult?: Result<[H, RouterRoute]>;
574
+ matchResult?: Result<[
575
+ H,
576
+ RouterRoute
577
+ ]>;
582
578
  path?: string;
583
579
  };
584
580
 
@@ -654,12 +650,9 @@ operation: string;
654
650
  plan: Record<string, unknown>;
655
651
  params: Record<string, unknown>;
656
652
  model?: string | undefined;
657
- comments?: Record<string, string> | undefined;
658
653
  };
659
654
  };
660
- output: {
661
- data: JSONValue;
662
- };
655
+ output: never;
663
656
  outputFormat: "json";
664
657
  status: ContentfulStatusCode;
665
658
  };
@@ -690,16 +683,13 @@ operation: string;
690
683
  plan: Record<string, unknown>;
691
684
  params: Record<string, unknown>;
692
685
  model?: string | undefined;
693
- comments?: Record<string, string> | undefined;
694
686
  };
695
687
  } & {
696
688
  param: {
697
689
  txId: string;
698
690
  };
699
691
  };
700
- output: {
701
- data: JSONValue;
702
- };
692
+ output: never;
703
693
  outputFormat: "json";
704
694
  status: ContentfulStatusCode;
705
695
  };
@@ -891,9 +881,7 @@ declare type ExtendedSpanOptions_2 = SpanOptions & {
891
881
  name: string;
892
882
  };
893
883
 
894
- declare type ExtractHandlerResponse<T> = T extends (c: any, next: any) => Promise<infer R> ? Exclude<R, void> extends never ? never : Exclude<R, void> extends Response | TypedResponse<any, any, any> ? Exclude<R, void> : never : T extends (c: any, next: any) => infer R ? R extends Response | TypedResponse<any, any, any> ? R : never : never;
895
-
896
- declare type ExtractInput<I extends Input | Input['in']> = I extends Input ? unknown extends I['in'] ? {} : I['in'] : I;
884
+ declare type ExtractInput<I extends Input | Input["in"]> = I extends Input ? unknown extends I["in"] ? {} : I["in"] : I;
897
885
 
898
886
  declare type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
899
887
  [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
@@ -975,148 +963,752 @@ declare type Fragment = {
975
963
  * @template E - Environment type.
976
964
  */
977
965
  declare interface Get<E extends Env> {
978
- <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
966
+ <Key extends keyof E["Variables"]>(key: Key): E["Variables"][Key];
979
967
  <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
980
968
  }
981
969
 
982
970
  declare const GET_MATCH_RESULT: symbol;
983
971
 
984
972
  declare type GetPath<E extends Env> = (request: Request, options?: {
985
- env?: E['Bindings'];
973
+ env?: E["Bindings"];
986
974
  }) => string;
987
975
 
988
- declare type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I, R>;
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>;
989
977
 
990
978
  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;
991
979
 
992
- declare interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/'> {
993
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
994
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, P, any> = H<E2, P, any>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath>;
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>;
995
996
  <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>;
996
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath>;
997
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath>;
998
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2> & M2, H<E4, P, I3> & M3, H<E5, P, I4, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
999
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>>(path: P, ...handlers: [H<E2, MergedPath, I> & M1, H<E3, MergedPath, I2> & M2, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2>>, BasePath>;
1000
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>>(...handlers: [
1001
- H<E2, P, I> & M1,
1002
- H<E3, P, I2> & M2,
1003
- H<E4, P, I3> & M3,
1004
- H<E5, P, I4> & M4,
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>,
1005
1080
  H<E6, P, I5, R>
1006
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
1007
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>>(path: P, ...handlers: [
1008
- H<E2, MergedPath, I> & M1,
1009
- H<E3, MergedPath, I2> & M2,
1010
- H<E4, MergedPath, I3> & M3,
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>,
1011
1105
  H<E5, MergedPath, I4, R>
1012
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3>>, BasePath>;
1013
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>>(...handlers: [
1014
- H<E2, P, I> & M1,
1015
- H<E3, P, I2> & M2,
1016
- H<E4, P, I3> & M3,
1017
- H<E5, P, I4> & M4,
1018
- H<E6, P, I5> & M5,
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>,
1019
1138
  H<E7, P, I6, R>
1020
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, P, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath>;
1021
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>>(path: P, ...handlers: [
1022
- H<E2, MergedPath, I> & M1,
1023
- H<E3, MergedPath, I2> & M2,
1024
- H<E4, MergedPath, I3> & M3,
1025
- H<E5, MergedPath, I4> & M4,
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>,
1026
1171
  H<E6, MergedPath, I5, R>
1027
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4>>, BasePath>;
1028
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>>(...handlers: [
1029
- H<E2, P, I> & M1,
1030
- H<E3, P, I2> & M2,
1031
- H<E4, P, I3> & M3,
1032
- H<E5, P, I4> & M4,
1033
- H<E6, P, I5> & M5,
1034
- H<E7, P, I6> & M6,
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>,
1035
1213
  H<E8, P, I7, R>
1036
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, P, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath>;
1037
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>>(path: P, ...handlers: [
1038
- H<E2, MergedPath, I> & M1,
1039
- H<E3, MergedPath, I2> & M2,
1040
- H<E4, MergedPath, I3> & M3,
1041
- H<E5, MergedPath, I4> & M4,
1042
- H<E6, MergedPath, I5> & M5,
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>,
1043
1255
  H<E7, MergedPath, I6, R>
1044
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5>>, BasePath>;
1045
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>>(...handlers: [
1046
- H<E2, P, I> & M1,
1047
- H<E3, P, I2> & M2,
1048
- H<E4, P, I3> & M3,
1049
- H<E5, P, I4> & M4,
1050
- H<E6, P, I5> & M5,
1051
- H<E7, P, I6> & M6,
1052
- H<E8, P, I7> & M7,
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>,
1053
1307
  H<E9, P, I8, R>
1054
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, P, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath>;
1055
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>>(path: P, ...handlers: [
1056
- H<E2, MergedPath, I> & M1,
1057
- H<E3, MergedPath, I2> & M2,
1058
- H<E4, MergedPath, I3> & M3,
1059
- H<E5, MergedPath, I4> & M4,
1060
- H<E6, MergedPath, I5> & M5,
1061
- H<E7, MergedPath, I6> & M6,
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>,
1062
1359
  H<E8, MergedPath, I7, R>
1063
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6>>, BasePath>;
1064
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>>(...handlers: [
1065
- H<E2, P, I> & M1,
1066
- H<E3, P, I2> & M2,
1067
- H<E4, P, I3> & M3,
1068
- H<E5, P, I4> & M4,
1069
- H<E6, P, I5> & M5,
1070
- H<E7, P, I6> & M6,
1071
- H<E8, P, I7> & M7,
1072
- H<E9, P, I8> & M8,
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>,
1073
1422
  H<E10, P, I9, R>
1074
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, P, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath>;
1075
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>>(path: P, ...handlers: [
1076
- H<E2, MergedPath, I> & M1,
1077
- H<E3, MergedPath, I2> & M2,
1078
- H<E4, MergedPath, I3> & M3,
1079
- H<E5, MergedPath, I4> & M4,
1080
- H<E6, MergedPath, I5> & M5,
1081
- H<E7, MergedPath, I6> & M6,
1082
- H<E8, MergedPath, I7> & M7,
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>,
1083
1485
  H<E9, MergedPath, I8, R>
1084
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7>>, BasePath>;
1085
- <P extends string = ExtractStringKey<S> extends never ? BasePath : ExtractStringKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, M1 extends H<E2, P, any> = H<E2, P, any>, M2 extends H<E3, P, any> = H<E3, P, any>, M3 extends H<E4, P, any> = H<E4, P, any>, M4 extends H<E5, P, any> = H<E5, P, any>, M5 extends H<E6, P, any> = H<E6, P, any>, M6 extends H<E7, P, any> = H<E7, P, any>, M7 extends H<E8, P, any> = H<E8, P, any>, M8 extends H<E9, P, any> = H<E9, P, any>, M9 extends H<E10, P, any> = H<E10, P, any>>(...handlers: [
1086
- H<E2, P, I> & M1,
1087
- H<E3, P, I2> & M2,
1088
- H<E4, P, I3> & M3,
1089
- H<E5, P, I4> & M4,
1090
- H<E6, P, I5> & M5,
1091
- H<E7, P, I6> & M6,
1092
- H<E8, P, I7> & M7,
1093
- H<E9, P, I8> & M8,
1094
- H<E10, P, I9> & M9,
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>,
1095
1560
  H<E11, P, I10, R>
1096
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath>;
1097
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>>(path: P, ...handlers: [
1098
- H<E2, MergedPath, I> & M1,
1099
- H<E3, MergedPath, I2> & M2,
1100
- H<E4, MergedPath, I3> & M3,
1101
- H<E5, MergedPath, I4> & M4,
1102
- H<E6, MergedPath, I5> & M5,
1103
- H<E7, MergedPath, I6> & M6,
1104
- H<E8, MergedPath, I7> & M7,
1105
- H<E9, MergedPath, I8> & M8,
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>,
1106
1635
  H<E10, MergedPath, I9, R>
1107
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8>>, BasePath>;
1108
- <P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, M1 extends H<E2, MergedPath, any> = H<E2, MergedPath, any>, M2 extends H<E3, MergedPath, any> = H<E3, MergedPath, any>, M3 extends H<E4, MergedPath, any> = H<E4, MergedPath, any>, M4 extends H<E5, MergedPath, any> = H<E5, MergedPath, any>, M5 extends H<E6, MergedPath, any> = H<E6, MergedPath, any>, M6 extends H<E7, MergedPath, any> = H<E7, MergedPath, any>, M7 extends H<E8, MergedPath, any> = H<E8, MergedPath, any>, M8 extends H<E9, MergedPath, any> = H<E9, MergedPath, any>, M9 extends H<E10, MergedPath, any> = H<E10, MergedPath, any>>(path: P, ...handlers: [
1109
- H<E2, MergedPath, I> & M1,
1110
- H<E3, MergedPath, I2> & M2,
1111
- H<E4, MergedPath, I3> & M3,
1112
- H<E5, MergedPath, I4> & M4,
1113
- H<E6, MergedPath, I5> & M5,
1114
- H<E7, MergedPath, I6> & M6,
1115
- H<E8, MergedPath, I7> & M7,
1116
- H<E9, MergedPath, I8> & M8,
1117
- H<E10, MergedPath, I9> & M9,
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>,
1118
1710
  H<E11, MergedPath, I10, R>
1119
- ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R> | MergeMiddlewareResponse<M1> | MergeMiddlewareResponse<M2> | MergeMiddlewareResponse<M3> | MergeMiddlewareResponse<M4> | MergeMiddlewareResponse<M5> | MergeMiddlewareResponse<M6> | MergeMiddlewareResponse<M7> | MergeMiddlewareResponse<M8> | MergeMiddlewareResponse<M9>>, BasePath>;
1711
+ ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
1120
1712
  <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>;
1121
1713
  <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>;
1122
1714
  <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>;
@@ -1124,25 +1716,25 @@ declare interface HandlerInterface<E extends Env = Env, M extends string = strin
1124
1716
 
1125
1717
  declare type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
1126
1718
 
1127
- declare type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
1128
-
1129
- declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
1719
+ declare type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
1130
1720
 
1131
- get: HandlerInterface<E, 'get', S, BasePath>;
1132
- post: HandlerInterface<E, 'post', S, BasePath>;
1133
- put: HandlerInterface<E, 'put', S, BasePath>;
1134
- delete: HandlerInterface<E, 'delete', S, BasePath>;
1135
- options: HandlerInterface<E, 'options', S, BasePath>;
1136
- patch: HandlerInterface<E, 'patch', S, BasePath>;
1137
- all: HandlerInterface<E, 'all', S, BasePath>;
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>;
1138
1729
  on: OnHandlerInterface<E, S, BasePath>;
1139
1730
  use: MiddlewareHandlerInterface<E, S, BasePath>;
1140
- router: Router<[H, RouterRoute]>;
1731
+ router: Router<[
1732
+ H,
1733
+ RouterRoute
1734
+ ]>;
1141
1735
  readonly getPath: GetPath<E>;
1142
- private _basePath;
1143
1736
  routes: RouterRoute[];
1144
1737
  constructor(options?: HonoOptions<E>);
1145
- private errorHandler;
1146
1738
  /**
1147
1739
  * `.route()` allows grouping other Hono instance in routes.
1148
1740
  *
@@ -1253,7 +1845,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
1253
1845
  * @returns {Response | Promise<Response>} response of request
1254
1846
  *
1255
1847
  */
1256
- fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1848
+ fetch: (request: Request, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
1257
1849
  /**
1258
1850
  * `.request()` is a useful method for testing.
1259
1851
  * You can pass a URL or pathname to send a GET request.
@@ -1306,7 +1898,10 @@ declare type HonoOptions<E extends Env> = {
1306
1898
  * const app = new Hono({ router: new RegExpRouter() })
1307
1899
  * ```
1308
1900
  */
1309
- router?: Router<[H, RouterRoute]>;
1901
+ router?: Router<[
1902
+ H,
1903
+ RouterRoute
1904
+ ]>;
1310
1905
  /**
1311
1906
  * `getPath` can handle the host header value.
1312
1907
  *
@@ -1330,9 +1925,11 @@ declare type HonoOptions<E extends Env> = {
1330
1925
  getPath?: GetPath<E>;
1331
1926
  };
1332
1927
 
1333
- declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
1334
-
1335
- [GET_MATCH_RESULT]: Result<[unknown, RouterRoute]>;
1928
+ declare class HonoRequest<P extends string = "/", I extends Input["out"] = {}> {
1929
+ [GET_MATCH_RESULT]: Result<[
1930
+ unknown,
1931
+ RouterRoute
1932
+ ]>;
1336
1933
  /**
1337
1934
  * `.raw` can get the raw Request object.
1338
1935
  *
@@ -1363,7 +1960,10 @@ declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
1363
1960
  */
1364
1961
  path: string;
1365
1962
  bodyCache: BodyCache;
1366
- constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
1963
+ constructor(request: Request, path?: string, matchResult?: Result<[
1964
+ unknown,
1965
+ RouterRoute
1966
+ ]>);
1367
1967
  /**
1368
1968
  * `.req.param()` gets the path parameters.
1369
1969
  *
@@ -1661,11 +2261,14 @@ declare type Input = {
1661
2261
  outputFormat?: ResponseFormat;
1662
2262
  };
1663
2263
 
1664
- declare type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends {
2264
+ declare type InputToDataByTarget<T extends Input["out"], Target extends keyof ValidationTargets> = T extends {
1665
2265
  [K in Target]: infer R;
1666
2266
  } ? R : never;
1667
2267
 
1668
- declare type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
2268
+ declare type IntersectNonAnyTypes<T extends any[]> = T extends [
2269
+ infer Head,
2270
+ ...infer Rest
2271
+ ] ? ProcessHead<Head> & IntersectNonAnyTypes<Rest> : {};
1669
2272
 
1670
2273
  declare type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
1671
2274
 
@@ -1690,28 +2293,15 @@ declare type JSONObject = {
1690
2293
  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
1691
2294
  };
1692
2295
 
1693
- /**
1694
- * Convert a type to a JSON-compatible type.
1695
- *
1696
- * Non-JSON values such as `Date` implement `.toJSON()`,
1697
- * so they can be transformed to a value assignable to `JSONObject`
1698
- *
1699
- * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
1700
- * unless a custom `replacer` function or `.toJSON()` method is provided.
1701
- *
1702
- * This behaviour can be controlled by the `TError` generic type parameter,
1703
- * which defaults to `bigint | ReadonlyArray<bigint>`.
1704
- * You can set it to `never` to disable this check.
1705
- */
1706
- declare type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
2296
+ declare type JSONParsed<T> = T extends {
1707
2297
  toJSON(): infer J;
1708
2298
  } ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
1709
2299
  toJSON(): unknown;
1710
- } ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? {
1711
- [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
1712
- } : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
1713
- [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError>;
1714
- } : T extends unknown ? T extends TError ? never : JSONValue : never;
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;
1715
2305
 
1716
2306
  declare type JSONPrimitive = string | boolean | number | null;
1717
2307
 
@@ -1729,21 +2319,21 @@ declare type JSONPrimitive = string | boolean | number | null;
1729
2319
  * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
1730
2320
  */
1731
2321
  declare interface JSONRespond {
1732
- <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
1733
- <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
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>;
1734
2324
  }
1735
2325
 
1736
2326
  /**
1737
2327
  * @template T - The type of the JSON value or simplified unknown type.
1738
2328
  * @template U - The type of the status code.
1739
2329
  *
1740
- * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
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.
1741
2331
  */
1742
- declare type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
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">;
1743
2333
 
1744
2334
  declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
1745
2335
 
1746
- declare type KnownResponseFormat = 'json' | 'text' | 'redirect';
2336
+ declare type KnownResponseFormat = "json" | "text" | "redirect";
1747
2337
 
1748
2338
  declare type Layout<T = Record<string, any>> = (props: T) => any;
1749
2339
 
@@ -1885,28 +2475,28 @@ declare interface LogSink {
1885
2475
  }
1886
2476
 
1887
2477
  declare type MergeEndpointParamsWithPath<T extends Endpoint, SubPath extends string> = T extends unknown ? {
1888
- input: T['input'] extends {
2478
+ input: T["input"] extends {
1889
2479
  param: infer _;
1890
- } ? ExtractParams<SubPath> extends never ? T['input'] : FlattenIfIntersect<T['input'] & {
2480
+ } ? ExtractParams<SubPath> extends never ? T["input"] : FlattenIfIntersect<T["input"] & {
1891
2481
  param: {
1892
2482
  [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
1893
2483
  };
1894
- }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T['input'] : T['input'] & {
2484
+ }> : RemoveBlankRecord<ExtractParams<SubPath>> extends never ? T["input"] : T["input"] & {
1895
2485
  param: {
1896
2486
  [K in keyof ExtractParams<SubPath> as K extends `${infer Prefix}{${infer _}}` ? Prefix : K]: string;
1897
2487
  };
1898
2488
  };
1899
- output: T['output'];
1900
- outputFormat: T['outputFormat'];
1901
- status: T['status'];
2489
+ output: T["output"];
2490
+ outputFormat: T["outputFormat"];
2491
+ status: T["status"];
1902
2492
  } : never;
1903
2493
 
1904
- declare type MergeMiddlewareResponse<T> = MergeTypedResponseStrict<ExtractHandlerResponse<T>>;
1905
-
1906
- declare type MergePath<A extends string, B extends string> = B extends '' ? MergePath<A, '/'> : A extends '' ? B : A extends '/' ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends '' ? A : `${A}/${Q}` : `${A}/${B}`;
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}`;
1907
2495
 
1908
2496
  declare type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string> = {
1909
- [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [OrigSchema[P]] extends [
2497
+ [P in keyof OrigSchema as MergePath<SubPath, P & string>]: [
2498
+ OrigSchema[P]
2499
+ ] extends [
1910
2500
  Record<string, Endpoint>
1911
2501
  ] ? {
1912
2502
  [M in keyof OrigSchema[P]]: MergeEndpointParamsWithPath<OrigSchema[P][M], SubPath>;
@@ -1915,57 +2505,264 @@ declare type MergeSchemaPath<OrigSchema extends Schema, SubPath extends string>
1915
2505
 
1916
2506
  declare type MergeTypedResponse<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : TypedResponse : T extends TypedResponse ? T : TypedResponse;
1917
2507
 
1918
- declare type MergeTypedResponseStrict<T> = T extends Promise<infer T2> ? T2 extends TypedResponse ? T2 : never : T extends TypedResponse ? T : never;
1919
-
1920
- declare type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> = Response> = (c: Context_2<E, P, I>, next: Next) => Promise<R | void>;
1921
-
1922
- declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
1923
- <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
1924
- <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractStringKey<S>>>): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
1925
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath>;
1926
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath, any, any>): Hono<IntersectNonAnyTypes<[E, E2]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1927
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
1928
- MiddlewareHandler<E2, P, any, any>,
1929
- MiddlewareHandler<E3, P, any, any>,
1930
- MiddlewareHandler<E4, P, any, any>
1931
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath>;
1932
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1933
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
1934
2575
  MiddlewareHandler<E2, P>,
1935
2576
  MiddlewareHandler<E3, P>,
1936
2577
  MiddlewareHandler<E4, P>,
1937
2578
  MiddlewareHandler<E5, P>
1938
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath>;
1939
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1940
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
1941
2622
  MiddlewareHandler<E2, P>,
1942
2623
  MiddlewareHandler<E3, P>,
1943
2624
  MiddlewareHandler<E4, P>,
1944
2625
  MiddlewareHandler<E5, P>,
1945
2626
  MiddlewareHandler<E6, P>
1946
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath>;
1947
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
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: [
1948
2648
  MiddlewareHandler<E2, P>,
1949
2649
  MiddlewareHandler<E3, P>,
1950
2650
  MiddlewareHandler<E4, P>,
1951
2651
  MiddlewareHandler<E5, P>
1952
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1953
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
1954
2685
  MiddlewareHandler<E2, P>,
1955
2686
  MiddlewareHandler<E3, P>,
1956
2687
  MiddlewareHandler<E4, P>,
1957
2688
  MiddlewareHandler<E5, P>,
1958
2689
  MiddlewareHandler<E6, P>,
1959
2690
  MiddlewareHandler<E7, P>
1960
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath>;
1961
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
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: [
1962
2719
  MiddlewareHandler<E2, P>,
1963
2720
  MiddlewareHandler<E3, P>,
1964
2721
  MiddlewareHandler<E4, P>,
1965
2722
  MiddlewareHandler<E5, P>,
1966
2723
  MiddlewareHandler<E6, P>
1967
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1968
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
1969
2766
  MiddlewareHandler<E2, P>,
1970
2767
  MiddlewareHandler<E3, P>,
1971
2768
  MiddlewareHandler<E4, P>,
@@ -1973,16 +2770,100 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
1973
2770
  MiddlewareHandler<E6, P>,
1974
2771
  MiddlewareHandler<E7, P>,
1975
2772
  MiddlewareHandler<E8, P>
1976
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath>;
1977
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
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: [
1978
2809
  MiddlewareHandler<E2, P>,
1979
2810
  MiddlewareHandler<E3, P>,
1980
2811
  MiddlewareHandler<E4, P>,
1981
2812
  MiddlewareHandler<E5, P>,
1982
2813
  MiddlewareHandler<E6, P>,
1983
2814
  MiddlewareHandler<E7, P>
1984
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
1985
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
1986
2867
  MiddlewareHandler<E2, P>,
1987
2868
  MiddlewareHandler<E3, P>,
1988
2869
  MiddlewareHandler<E4, P>,
@@ -1991,8 +2872,51 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
1991
2872
  MiddlewareHandler<E7, P>,
1992
2873
  MiddlewareHandler<E8, P>,
1993
2874
  MiddlewareHandler<E9, P>
1994
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath>;
1995
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
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: [
1996
2920
  MiddlewareHandler<E2, P>,
1997
2921
  MiddlewareHandler<E3, P>,
1998
2922
  MiddlewareHandler<E4, P>,
@@ -2000,8 +2924,69 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2000
2924
  MiddlewareHandler<E6, P>,
2001
2925
  MiddlewareHandler<E7, P>,
2002
2926
  MiddlewareHandler<E8, P>
2003
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2004
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
2005
2990
  MiddlewareHandler<E2, P>,
2006
2991
  MiddlewareHandler<E3, P>,
2007
2992
  MiddlewareHandler<E4, P>,
@@ -2011,8 +2996,61 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2011
2996
  MiddlewareHandler<E8, P>,
2012
2997
  MiddlewareHandler<E9, P>,
2013
2998
  MiddlewareHandler<E10, P>
2014
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath>;
2015
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
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: [
2016
3054
  MiddlewareHandler<E2, P>,
2017
3055
  MiddlewareHandler<E3, P>,
2018
3056
  MiddlewareHandler<E4, P>,
@@ -2021,8 +3059,81 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2021
3059
  MiddlewareHandler<E7, P>,
2022
3060
  MiddlewareHandler<E8, P>,
2023
3061
  MiddlewareHandler<E9, P>
2024
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
2025
- <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, P extends string = MergePath<BasePath, ExtractStringKey<S>>>(...handlers: [
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: [
2026
3137
  MiddlewareHandler<E2, P>,
2027
3138
  MiddlewareHandler<E3, P>,
2028
3139
  MiddlewareHandler<E4, P>,
@@ -2033,8 +3144,72 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2033
3144
  MiddlewareHandler<E9, P>,
2034
3145
  MiddlewareHandler<E10, P>,
2035
3146
  MiddlewareHandler<E11, P>
2036
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath>;
2037
- <P extends string, MergedPath extends MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
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: [
2038
3213
  MiddlewareHandler<E2, P>,
2039
3214
  MiddlewareHandler<E3, P>,
2040
3215
  MiddlewareHandler<E4, P>,
@@ -2044,7 +3219,18 @@ declare interface MiddlewareHandlerInterface<E extends Env = Env, S extends Sche
2044
3219
  MiddlewareHandler<E8, P>,
2045
3220
  MiddlewareHandler<E9, P>,
2046
3221
  MiddlewareHandler<E10, P>
2047
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
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>;
2048
3234
  <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
2049
3235
  }
2050
3236
 
@@ -2078,32 +3264,170 @@ declare type OmitSymbolKeys<T> = {
2078
3264
  [K in keyof T as K extends symbol ? never : K]: T[K];
2079
3265
  };
2080
3266
 
2081
- declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
2082
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
2083
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
2084
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
2085
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(method: M, path: P, ...handlers: [
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: [
2086
3313
  H<E2, MergedPath, I>,
2087
3314
  H<E3, MergedPath, I2>,
2088
3315
  H<E4, MergedPath, I3>,
2089
3316
  H<E5, MergedPath, I4, R>
2090
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
2091
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(method: M, path: P, ...handlers: [
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: [
2092
3343
  H<E2, MergedPath, I>,
2093
3344
  H<E3, MergedPath, I2>,
2094
3345
  H<E4, MergedPath, I3>,
2095
3346
  H<E5, MergedPath, I4>,
2096
3347
  H<E6, MergedPath, I5, R>
2097
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
2098
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(method: M, path: P, ...handlers: [
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: [
2099
3382
  H<E2, MergedPath, I>,
2100
3383
  H<E3, MergedPath, I2>,
2101
3384
  H<E4, MergedPath, I3>,
2102
3385
  H<E5, MergedPath, I4>,
2103
3386
  H<E6, MergedPath, I5>,
2104
3387
  H<E7, MergedPath, I6, R>
2105
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
2106
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(method: M, path: P, ...handlers: [
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: [
2107
3431
  H<E2, MergedPath, I>,
2108
3432
  H<E3, MergedPath, I2>,
2109
3433
  H<E4, MergedPath, I3>,
@@ -2111,8 +3435,59 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2111
3435
  H<E6, MergedPath, I5>,
2112
3436
  H<E7, MergedPath, I6>,
2113
3437
  H<E8, MergedPath, I7, R>
2114
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
2115
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(method: M, path: P, ...handlers: [
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: [
2116
3491
  H<E2, MergedPath, I>,
2117
3492
  H<E3, MergedPath, I2>,
2118
3493
  H<E4, MergedPath, I3>,
@@ -2121,8 +3496,70 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2121
3496
  H<E7, MergedPath, I6>,
2122
3497
  H<E8, MergedPath, I7>,
2123
3498
  H<E9, MergedPath, I8, R>
2124
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
2125
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(method: M, path: P, ...handlers: [
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: [
2126
3563
  H<E2, MergedPath, I>,
2127
3564
  H<E3, MergedPath, I2>,
2128
3565
  H<E4, MergedPath, I3>,
@@ -2132,8 +3569,82 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2132
3569
  H<E8, MergedPath, I7>,
2133
3570
  H<E9, MergedPath, I8>,
2134
3571
  H<E10, MergedPath, I9, R>
2135
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
2136
- <M extends string, P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(method: M, path: P, ...handlers: [
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: [
2137
3648
  H<E2, MergedPath, I>,
2138
3649
  H<E3, MergedPath, I2>,
2139
3650
  H<E4, MergedPath, I3>,
@@ -2144,33 +3655,183 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2144
3655
  H<E9, MergedPath, I8>,
2145
3656
  H<E10, MergedPath, I9>,
2146
3657
  H<E11, MergedPath, I10, R>
2147
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
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>;
2148
3671
  <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>;
2149
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
2150
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
2151
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
2152
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(methods: Ms, path: P, ...handlers: [
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: [
2153
3717
  H<E2, MergedPath, I>,
2154
3718
  H<E3, MergedPath, I2>,
2155
3719
  H<E4, MergedPath, I3>,
2156
3720
  H<E5, MergedPath, I4, R>
2157
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
2158
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(methods: Ms, path: P, ...handlers: [
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: [
2159
3747
  H<E2, MergedPath, I>,
2160
3748
  H<E3, MergedPath, I2>,
2161
3749
  H<E4, MergedPath, I3>,
2162
3750
  H<E5, MergedPath, I4>,
2163
3751
  H<E6, MergedPath, I5, R>
2164
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
2165
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(methods: Ms, path: P, ...handlers: [
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: [
2166
3786
  H<E2, MergedPath, I>,
2167
3787
  H<E3, MergedPath, I2>,
2168
3788
  H<E4, MergedPath, I3>,
2169
3789
  H<E5, MergedPath, I4>,
2170
3790
  H<E6, MergedPath, I5>,
2171
3791
  H<E7, MergedPath, I6, R>
2172
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
2173
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(methods: Ms, path: P, ...handlers: [
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: [
2174
3835
  H<E2, MergedPath, I>,
2175
3836
  H<E3, MergedPath, I2>,
2176
3837
  H<E4, MergedPath, I3>,
@@ -2178,8 +3839,59 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2178
3839
  H<E6, MergedPath, I5>,
2179
3840
  H<E7, MergedPath, I6>,
2180
3841
  H<E8, MergedPath, I7, R>
2181
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
2182
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(methods: Ms, path: P, ...handlers: [
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: [
2183
3895
  H<E2, MergedPath, I>,
2184
3896
  H<E3, MergedPath, I2>,
2185
3897
  H<E4, MergedPath, I3>,
@@ -2188,8 +3900,70 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2188
3900
  H<E7, MergedPath, I6>,
2189
3901
  H<E8, MergedPath, I7>,
2190
3902
  H<E9, MergedPath, I8, R>
2191
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
2192
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(methods: Ms, path: P, ...handlers: [
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: [
2193
3967
  H<E2, MergedPath, I>,
2194
3968
  H<E3, MergedPath, I2>,
2195
3969
  H<E4, MergedPath, I3>,
@@ -2199,8 +3973,82 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2199
3973
  H<E8, MergedPath, I7>,
2200
3974
  H<E9, MergedPath, I8>,
2201
3975
  H<E10, MergedPath, I9, R>
2202
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
2203
- <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(methods: Ms, path: P, ...handlers: [
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: [
2204
4052
  H<E2, MergedPath, I>,
2205
4053
  H<E3, MergedPath, I2>,
2206
4054
  H<E4, MergedPath, I3>,
@@ -2211,7 +4059,19 @@ declare interface OnHandlerInterface<E extends Env = Env, S extends Schema = Bla
2211
4059
  H<E9, MergedPath, I8>,
2212
4060
  H<E10, MergedPath, I9>,
2213
4061
  H<E11, MergedPath, I10, R>
2214
- ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
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>;
2215
4075
  <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>;
2216
4076
  <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>;
2217
4077
  }
@@ -2376,7 +4236,12 @@ declare type ProcessHead<T> = IfAnyThenEmptyObject<T extends Env ? (Env extends
2376
4236
  /**
2377
4237
  * Extracts the props for the renderer.
2378
4238
  */
2379
- declare type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
4239
+ declare type PropsForRenderer = [
4240
+ ...Required<Parameters<Renderer>>
4241
+ ] extends [
4242
+ unknown,
4243
+ infer Props
4244
+ ] ? Props : unknown;
2380
4245
 
2381
4246
  declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver';
2382
4247
 
@@ -2549,7 +4414,7 @@ declare type Renderer = ContextRenderer extends Function ? ContextRenderer : Def
2549
4414
  * @module
2550
4415
  * HTTP Headers utility.
2551
4416
  */
2552
- declare type RequestHeader = 'A-IM' | 'Accept' | 'Accept-Additions' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Datetime' | 'Accept-Encoding' | 'Accept-Features' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Accept-Signature' | 'Access-Control' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'ALPN' | 'Alt-Svc' | 'Alt-Used' | 'Alternates' | 'AMP-Cache-Transform' | 'Apply-To-Redirect-Ref' | 'Authentication-Control' | 'Authentication-Info' | 'Authorization' | 'Available-Dictionary' | 'C-Ext' | 'C-Man' | 'C-Opt' | 'C-PEP' | 'C-PEP-Info' | 'Cache-Control' | 'Cache-Status' | 'Cal-Managed-ID' | 'CalDAV-Timezones' | 'Capsule-Protocol' | 'CDN-Cache-Control' | 'CDN-Loop' | 'Cert-Not-After' | 'Cert-Not-Before' | 'Clear-Site-Data' | 'Client-Cert' | 'Client-Cert-Chain' | 'Close' | 'CMCD-Object' | 'CMCD-Request' | 'CMCD-Session' | 'CMCD-Status' | 'CMSD-Dynamic' | 'CMSD-Static' | 'Concealed-Auth-Export' | 'Configuration-Context' | 'Connection' | 'Content-Base' | 'Content-Digest' | 'Content-Disposition' | 'Content-Encoding' | 'Content-ID' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-MD5' | 'Content-Range' | 'Content-Script-Type' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Style-Type' | 'Content-Type' | 'Content-Version' | 'Cookie' | 'Cookie2' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Embedder-Policy-Report-Only' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Opener-Policy-Report-Only' | 'Cross-Origin-Resource-Policy' | 'CTA-Common-Access-Token' | 'DASL' | 'Date' | 'DAV' | 'Default-Style' | 'Delta-Base' | 'Deprecation' | 'Depth' | 'Derived-From' | 'Destination' | 'Differential-ID' | 'Dictionary-ID' | 'Digest' | 'DPoP' | 'DPoP-Nonce' | 'Early-Data' | 'EDIINT-Features' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Ext' | 'Forwarded' | 'From' | 'GetProfile' | 'Hobareg' | 'Host' | 'HTTP2-Settings' | 'If' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Schedule-Tag-Match' | 'If-Unmodified-Since' | 'IM' | 'Include-Referred-Token-Binding-ID' | 'Isolation' | 'Keep-Alive' | 'Label' | 'Last-Event-ID' | 'Last-Modified' | 'Link' | 'Link-Template' | 'Location' | 'Lock-Token' | 'Man' | 'Max-Forwards' | 'Memento-Datetime' | 'Meter' | 'Method-Check' | 'Method-Check-Expires' | 'MIME-Version' | 'Negotiate' | 'NEL' | 'OData-EntityId' | 'OData-Isolation' | 'OData-MaxVersion' | 'OData-Version' | 'Opt' | 'Optional-WWW-Authenticate' | 'Ordering-Type' | 'Origin' | 'Origin-Agent-Cluster' | 'OSCORE' | 'OSLC-Core-Version' | 'Overwrite' | 'P3P' | 'PEP' | 'PEP-Info' | 'Permissions-Policy' | 'PICS-Label' | 'Ping-From' | 'Ping-To' | 'Position' | 'Pragma' | 'Prefer' | 'Preference-Applied' | 'Priority' | 'ProfileObject' | 'Protocol' | 'Protocol-Info' | 'Protocol-Query' | 'Protocol-Request' | 'Proxy-Authenticate' | 'Proxy-Authentication-Info' | 'Proxy-Authorization' | 'Proxy-Features' | 'Proxy-Instruction' | 'Proxy-Status' | 'Public' | 'Public-Key-Pins' | 'Public-Key-Pins-Report-Only' | 'Range' | 'Redirect-Ref' | 'Referer' | 'Referer-Root' | 'Referrer-Policy' | 'Refresh' | 'Repeatability-Client-ID' | 'Repeatability-First-Sent' | 'Repeatability-Request-ID' | 'Repeatability-Result' | 'Replay-Nonce' | 'Reporting-Endpoints' | 'Repr-Digest' | 'Retry-After' | 'Safe' | 'Schedule-Reply' | 'Schedule-Tag' | 'Sec-GPC' | 'Sec-Purpose' | 'Sec-Token-Binding' | 'Sec-WebSocket-Accept' | 'Sec-WebSocket-Extensions' | 'Sec-WebSocket-Key' | 'Sec-WebSocket-Protocol' | 'Sec-WebSocket-Version' | 'Security-Scheme' | 'Server' | 'Server-Timing' | 'Set-Cookie' | 'Set-Cookie2' | 'SetProfile' | 'Signature' | 'Signature-Input' | 'SLUG' | 'SoapAction' | 'Status-URI' | 'Strict-Transport-Security' | 'Sunset' | 'Surrogate-Capability' | 'Surrogate-Control' | 'TCN' | 'TE' | 'Timeout' | 'Timing-Allow-Origin' | 'Topic' | 'Traceparent' | 'Tracestate' | 'Trailer' | 'Transfer-Encoding' | 'TTL' | 'Upgrade' | 'Urgency' | 'URI' | 'Use-As-Dictionary' | 'User-Agent' | 'Variant-Vary' | 'Vary' | 'Via' | 'Want-Content-Digest' | 'Want-Digest' | 'Want-Repr-Digest' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options';
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";
2553
4418
 
2554
4419
  /**
2555
4420
  * Resource limits defined for the user.
@@ -2573,9 +4438,12 @@ declare type ResourceLimits = {
2573
4438
 
2574
4439
  declare type ResponseFormat = KnownResponseFormat | string;
2575
4440
 
2576
- declare type ResponseHeader = 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Age' | 'Allow' | 'Cache-Control' | 'Clear-Site-Data' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'ETag' | 'Expires' | 'Last-Modified' | 'Location' | 'Permissions-Policy' | 'Pragma' | 'Retry-After' | 'Save-Data' | 'Sec-CH-Prefers-Color-Scheme' | 'Sec-CH-Prefers-Reduced-Motion' | 'Sec-CH-UA' | 'Sec-CH-UA-Arch' | 'Sec-CH-UA-Bitness' | 'Sec-CH-UA-Form-Factor' | 'Sec-CH-UA-Full-Version' | 'Sec-CH-UA-Full-Version-List' | 'Sec-CH-UA-Mobile' | 'Sec-CH-UA-Model' | 'Sec-CH-UA-Platform' | 'Sec-CH-UA-Platform-Version' | 'Sec-CH-UA-WoW64' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-GPC' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'Strict-Transport-Security' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Vary' | 'WWW-Authenticate' | 'Warning' | 'X-Content-Type-Options' | 'X-DNS-Prefetch-Control' | 'X-Frame-Options' | 'X-Permitted-Cross-Domain-Policies' | 'X-Powered-By' | 'X-Robots-Tag' | 'X-XSS-Protection';
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";
2577
4442
 
2578
- declare type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
4443
+ declare type ResponseHeadersInit = [
4444
+ string,
4445
+ string
4446
+ ][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
2579
4447
 
2580
4448
  declare interface ResponseInit_2<T extends StatusCode = StatusCode> {
2581
4449
  headers?: ResponseHeadersInit;
@@ -2617,7 +4485,18 @@ declare type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit_2<
2617
4485
  * ]
2618
4486
  * ```
2619
4487
  */
2620
- declare type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
4488
+ declare type Result<T> = [
4489
+ [
4490
+ T,
4491
+ ParamIndexMap
4492
+ ][],
4493
+ ParamStash
4494
+ ] | [
4495
+ [
4496
+ T,
4497
+ Params
4498
+ ][]
4499
+ ];
2621
4500
 
2622
4501
  declare type ResultNode = {
2623
4502
  type: 'affectedRows';
@@ -2697,12 +4576,12 @@ declare type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 5
2697
4576
  * @template E - Environment type.
2698
4577
  */
2699
4578
  declare interface Set_2<E extends Env> {
2700
- <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
4579
+ <Key extends keyof E["Variables"]>(key: Key, value: E["Variables"][Key]): void;
2701
4580
  <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
2702
4581
  }
2703
4582
 
2704
4583
  declare interface SetHeaders {
2705
- (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
4584
+ (name: "Content-Type", value?: BaseMime, options?: SetHeadersOptions): void;
2706
4585
  (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
2707
4586
  (name: string, value?: string, options?: SetHeadersOptions): void;
2708
4587
  }
@@ -2723,6 +4602,13 @@ declare type SimplifyBodyData<T> = {
2723
4602
  [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;
2724
4603
  } & {};
2725
4604
 
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
+
2726
4612
  /**
2727
4613
  * An interface that represents a span. A span represents a single operation
2728
4614
  * within a trace. Examples of span might include remote procedure calls or a
@@ -3056,8 +4942,8 @@ export { Temporal }
3056
4942
  * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
3057
4943
  */
3058
4944
  declare interface TextRespond {
3059
- <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
3060
- <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
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">;
3061
4947
  }
3062
4948
 
3063
4949
  /**
@@ -3067,7 +4953,7 @@ declare interface TextRespond {
3067
4953
  */
3068
4954
  declare type TimeInput = HrTime | number | Date;
3069
4955
 
3070
- declare type ToSchema<M extends string, P extends string, I extends Input | Input['in'], RorO> = Simplify<{
4956
+ declare type ToSchema<M extends string, P extends string, I extends Input | Input["in"], RorO> = Simplify<{
3071
4957
  [K in P]: {
3072
4958
  [K2 in M as AddDollar<K2>]: Simplify<{
3073
4959
  input: AddParam<ExtractInput<I>, P>;
@@ -3079,13 +4965,13 @@ declare type ToSchema<M extends string, P extends string, I extends Input | Inpu
3079
4965
  output: unknown extends T ? {} : T;
3080
4966
  outputFormat: I extends {
3081
4967
  outputFormat: string;
3082
- } ? I['outputFormat'] : F;
4968
+ } ? I["outputFormat"] : F;
3083
4969
  status: U;
3084
4970
  } : {
3085
4971
  output: unknown extends RorO ? {} : RorO;
3086
- outputFormat: unknown extends RorO ? 'json' : I extends {
4972
+ outputFormat: unknown extends RorO ? "json" : I extends {
3087
4973
  outputFormat: string;
3088
- } ? I['outputFormat'] : 'json';
4974
+ } ? I["outputFormat"] : "json";
3089
4975
  status: StatusCode;
3090
4976
  })>;
3091
4977
  };
@@ -3279,7 +5165,7 @@ declare type TransactionOptions_2 = {
3279
5165
  isolationLevel?: IsolationLevel;
3280
5166
  };
3281
5167
 
3282
- declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat> = {
5168
+ declare type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = T extends string ? "text" : T extends JSONValue ? "json" : ResponseFormat> = {
3283
5169
  _data: T;
3284
5170
  _status: U;
3285
5171
  _format: F;