Open History to see the last commit
1import type { StartInstanceOptions } from './createStart'
2import type { AnyServerFn, ConstrainValidator, Method } from './createServerFn'
3import type {
4 AnyContext,
5 Assign,
6 Constrain,
7 Expand,
8 IntersectAssign,
9 Register,
10 ResolveValidatorInput,
11 ResolveValidatorOutput,
12 ValidateSerializableInput,
13} from '@tanstack/router-core'
14β
15export type CreateMiddlewareFn<TRegister> = <TType extends MiddlewareType>(
16 options?: {
17 type?: TType
18 },
19 __opts?: FunctionMiddlewareOptions<
20 TRegister,
21 unknown,
22 undefined,
23 undefined,
24 undefined
25 >,
26) => CreateMiddlewareResult<TRegister, TType>
27β
28export const createMiddleware: CreateMiddlewareFn<{}> = (options, __opts) => {
29 const resolvedOptions = {
30 type: 'request',
31 ...(__opts || options),
32 }
33β
34 return {
35 options: resolvedOptions,
36 middleware: (middleware: any) => {
37 return createMiddleware(
38 {} as any,
39 Object.assign(resolvedOptions, { middleware }),
40 ) as any
41 },
42 inputValidator: (inputValidator: any) => {
43 return createMiddleware(
44 {} as any,
45 Object.assign(resolvedOptions, { inputValidator }),
46 ) as any
47 },
48 client: (client: any) => {
49 return createMiddleware(
50 {} as any,
51 Object.assign(resolvedOptions, { client }),
52 ) as any
53 },
54 server: (server: any) => {
55 return createMiddleware(
56 {} as any,
57 Object.assign(resolvedOptions, { server }),
58 ) as any
59 },
60 } as any
61}
62β
63export type MiddlewareType = 'request' | 'function'
64β
65export type CreateMiddlewareResult<
66 TRegister,
67 TType extends MiddlewareType,
68> = 'request' extends TType
69 ? RequestMiddleware<TRegister>
70 : FunctionMiddleware<TRegister>
71β
72export interface FunctionMiddleware<TRegister>
73 extends FunctionMiddlewareAfterMiddleware<TRegister, unknown> {
74 middleware: <const TNewMiddlewares = undefined>(
75 middlewares: Constrain<
76 TNewMiddlewares,
77 ReadonlyArray<AnyRequestMiddleware | AnyFunctionMiddleware>
78 >,
79 ) => FunctionMiddlewareAfterMiddleware<TRegister, TNewMiddlewares>
80}
81β
82export interface FunctionMiddlewareAfterMiddleware<TRegister, TMiddlewares>
83 extends FunctionMiddlewareWithTypes<
84 TRegister,
85 TMiddlewares,
86 undefined,
87 undefined,
88 undefined,
89 undefined,
90 undefined
91 >,
92 FunctionMiddlewareServer<
93 TRegister,
94 TMiddlewares,
95 undefined,
96 undefined,
97 undefined
98 >,
99 FunctionMiddlewareClient<TRegister, TMiddlewares, undefined>,
100 FunctionMiddlewareValidator<TRegister, TMiddlewares> {}
101β
102export interface FunctionMiddlewareWithTypes<
103 TRegister,
104 TMiddlewares,
105 TInputValidator,
106 TServerContext,
107 TServerSendContext,
108 TClientContext,
109 TClientSendContext,
110> {
111 '~types': FunctionMiddlewareTypes<
112 TRegister,
113 TMiddlewares,
114 TInputValidator,
115 TServerContext,
116 TServerSendContext,
117 TClientContext,
118 TClientSendContext
119 >
120 options: FunctionMiddlewareOptions<
121 TRegister,
122 TMiddlewares,
123 TInputValidator,
124 TServerContext,
125 TClientContext
126 >
127}
128β
129export interface FunctionMiddlewareTypes<
130 in out TRegister,
131 in out TMiddlewares,
132 in out TInputValidator,
133 in out TServerContext,
134 in out TServerSendContext,
135 in out TClientContext,
136 in out TClientSendContext,
137> {
138 type: 'function'
139 middlewares: TMiddlewares
140 input: ResolveValidatorInput<TInputValidator>
141 allInput: IntersectAllValidatorInputs<TMiddlewares, TInputValidator>
142 output: ResolveValidatorOutput<TInputValidator>
143 allOutput: IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>
144 clientContext: TClientContext
145 allClientContextBeforeNext: AssignAllClientContextBeforeNext<
146 TMiddlewares,
147 TClientContext
148 >
149 allClientContextAfterNext: AssignAllClientContextAfterNext<
150 TMiddlewares,
151 TClientContext,
152 TClientSendContext
153 >
154 serverContext: TServerContext
155 serverSendContext: TServerSendContext
156 allServerSendContext: AssignAllServerSendContext<
157 TMiddlewares,
158 TServerSendContext
159 >
160 allServerContext: AssignAllServerFnContext<
161 TRegister,
162 TMiddlewares,
163 TServerSendContext,
164 TServerContext
165 >
166 clientSendContext: TClientSendContext
167 allClientSendContext: AssignAllClientSendContext<
168 TMiddlewares,
169 TClientSendContext
170 >
171 inputValidator: TInputValidator
172}
173β
174/**
175 * Recursively resolve the input type produced by a sequence of middleware
176 */
177export type IntersectAllValidatorInputs<TMiddlewares, TInputValidator> =
178 unknown extends TInputValidator
179 ? TInputValidator
180 : TInputValidator extends undefined
181 ? IntersectAllMiddleware<TMiddlewares, 'allInput'>
182 : IntersectAssign<
183 IntersectAllMiddleware<TMiddlewares, 'allInput'>,
184 ResolveValidatorInput<TInputValidator>
185 >
186β
187export type IntersectAllMiddleware<
188 TMiddlewares,
189 TType extends
190 | keyof AnyFunctionMiddleware['~types']
191 | keyof AnyRequestMiddleware['~types']
192 | keyof AnyServerFn['~types'],
193 TAcc = undefined,
194> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]
195 ? TMiddleware extends
196 | AnyFunctionMiddleware
197 | AnyRequestMiddleware
198 | AnyServerFn
199 ? IntersectAllMiddleware<
200 TRest,
201 TType,
202 IntersectAssign<
203 TAcc,
204 TMiddleware['~types'][TType & keyof TMiddleware['~types']]
205 >
206 >
207 : TAcc
208 : TAcc
209β
210export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<
211 any,
212 any,
213 any,
214 any,
215 any,
216 any,
217 any
218>
219β
220/**
221 * Recursively merge the output type produced by a sequence of middleware
222 */
223export type IntersectAllValidatorOutputs<TMiddlewares, TInputValidator> =
224 unknown extends TInputValidator
225 ? TInputValidator
226 : TInputValidator extends undefined
227 ? IntersectAllMiddleware<TMiddlewares, 'allOutput'>
228 : IntersectAssign<
229 IntersectAllMiddleware<TMiddlewares, 'allOutput'>,
230 ResolveValidatorOutput<TInputValidator>
231 >
232β
233/**
234 * Recursively resolve the client context type produced by a sequence of middleware
235 */
236export type AssignAllClientContextBeforeNext<
237 TMiddlewares,
238 TClientContext = undefined,
239> = unknown extends TClientContext
240 ? TClientContext
241 : Assign<
242 AssignAllMiddleware<TMiddlewares, 'allClientContextBeforeNext'>,
243 TClientContext
244 >
245β
246export type AssignAllMiddleware<
247 TMiddlewares,
248 TType extends
249 | keyof AnyFunctionMiddleware['~types']
250 | keyof AnyRequestMiddleware['~types']
251 | keyof AnyServerFn['~types'],
252 TAcc = undefined,
253> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]
254 ? TMiddleware extends
255 | AnyFunctionMiddleware
256 | AnyRequestMiddleware
257 | AnyServerFn
258 ? AssignAllMiddleware<
259 TRest,
260 TType,
261 Assign<TAcc, TMiddleware['~types'][TType & keyof TMiddleware['~types']]>
262 >
263 : TAcc
264 : TAcc
265β
266export type AssignAllClientContextAfterNext<
267 TMiddlewares,
268 TClientContext = undefined,
269 TSendContext = undefined,
270> = unknown extends TClientContext
271 ? Assign<TClientContext, TSendContext>
272 : Assign<
273 AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>,
274 Assign<TClientContext, TSendContext>
275 >
276β
277export type AssignAllServerSendContext<
278 TMiddlewares,
279 TSendContext = undefined,
280> = unknown extends TSendContext
281 ? TSendContext
282 : Assign<
283 AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>,
284 TSendContext
285 >
286β
287export type AssignAllServerRequestContext<
288 TRegister,
289 TMiddlewares,
290 TSendContext = undefined,
291 TServerContext = undefined,
292> = Assign<
293 // Fetch Request Context
294 GlobalFetchRequestContext,
295 Assign<
296 GlobalServerRequestContext<TRegister>,
297 __AssignAllServerRequestContext<TMiddlewares, TSendContext, TServerContext>
298 >
299>
300β
301// export type GlobalFetchRequestContext<TRegister> = AnyContext
302export type GlobalFetchRequestContext = Register extends {
303 server: { requestContext: infer TRequestContext }
304}
305 ? TRequestContext
306 : AnyContext
307β
308export type GlobalServerRequestContext<TRegister> = TRegister extends {
309 config: StartInstanceOptions<any, any, infer TRequestMiddlewares, any>
310}
311 ? AssignAllMiddleware<TRequestMiddlewares, 'allServerContext'>
312 : AnyContext
313β
314type __AssignAllServerRequestContext<
315 TMiddlewares,
316 TSendContext = undefined,
317 TServerContext = undefined,
318> = unknown extends TSendContext
319 ? Assign<TSendContext, TServerContext>
320 : Assign<
321 AssignAllMiddleware<TMiddlewares, 'allServerContext'>,
322 Assign<TSendContext, TServerContext>
323 >
324β
325export type AssignAllServerFnContext<
326 TRegister,
327 TMiddlewares,
328 TSendContext = undefined,
329 TServerContext = undefined,
330> = Assign<
331 GlobalFetchRequestContext,
332 Assign<
333 GlobalServerRequestContext<TRegister>, // TODO: This enabled global middleware
334 // type inference, but creates a circular types issue. No idea how to fix this.
335 // AnyContext,
336 Assign<
337 GlobalServerFnContext<TRegister>, // TODO: This enabled global middleware
338 // type inference, but creates a circular types issue. No idea how to fix this.
339 // AnyContext,/
340 __AssignAllServerFnContext<TMiddlewares, TSendContext, TServerContext>
341 >
342 >
343>
344β
345type GlobalServerFnContext<TRegister> = TRegister extends {
346 config: StartInstanceOptions<any, any, any, infer TFunctionMiddlewares>
347}
348 ? AssignAllMiddleware<TFunctionMiddlewares, 'allServerContext'>
349 : AnyContext
350β
351type __AssignAllServerFnContext<
352 TMiddlewares,
353 TSendContext = undefined,
354 TServerContext = undefined,
355> = unknown extends TSendContext
356 ? Assign<TSendContext, TServerContext>
357 : Assign<
358 AssignAllMiddleware<TMiddlewares, 'allServerContext'>,
359 Assign<TSendContext, TServerContext>
360 >
361β
362export type AssignAllClientSendContext<
363 TMiddlewares,
364 TSendContext = undefined,
365> = unknown extends TSendContext
366 ? TSendContext
367 : Assign<
368 AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>,
369 TSendContext
370 >
371β
372export interface FunctionMiddlewareOptions<
373 in out TRegister,
374 in out TMiddlewares,
375 in out TInputValidator,
376 in out TServerContext,
377 in out TClientContext,
378> {
379 middleware?: TMiddlewares
380 inputValidator?: ConstrainValidator<TRegister, 'GET', TInputValidator>
381 client?: FunctionMiddlewareClientFn<
382 TRegister,
383 TMiddlewares,
384 TInputValidator,
385 TServerContext,
386 TClientContext
387 >
388 server?: FunctionMiddlewareServerFn<
389 TRegister,
390 TMiddlewares,
391 TInputValidator,
392 TServerContext,
393 unknown,
394 unknown
395 >
396}
397β
398export type FunctionMiddlewareClientNextFn<TRegister, TMiddlewares> = <
399 TSendContext = undefined,
400 TNewClientContext = undefined,
401>(ctx?: {
402 context?: TNewClientContext
403 sendContext?: ValidateSerializableInput<TRegister, TSendContext>
404 headers?: HeadersInit
405}) => Promise<
406 FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>
407>
408β
409export interface FunctionMiddlewareServer<
410 TRegister,
411 TMiddlewares,
412 TInputValidator,
413 TServerSendContext,
414 TClientContext,
415> {
416 server: <TNewServerContext = undefined, TSendContext = undefined>(
417 server: FunctionMiddlewareServerFn<
418 TRegister,
419 TMiddlewares,
420 TInputValidator,
421 TServerSendContext,
422 TNewServerContext,
423 TSendContext
424 >,
425 ) => FunctionMiddlewareAfterServer<
426 TRegister,
427 TMiddlewares,
428 TInputValidator,
429 TNewServerContext,
430 TServerSendContext,
431 TClientContext,
432 TSendContext
433 >
434}
435β
436export type FunctionMiddlewareServerFn<
437 TRegister,
438 TMiddlewares,
439 TInputValidator,
440 TServerSendContext,
441 TNewServerContext,
442 TSendContext,
443> = (
444 options: FunctionMiddlewareServerFnOptions<
445 TRegister,
446 TMiddlewares,
447 TInputValidator,
448 TServerSendContext
449 >,
450) => FunctionMiddlewareServerFnResult<
451 TRegister,
452 TMiddlewares,
453 TServerSendContext,
454 TNewServerContext,
455 TSendContext
456>
457β
458export type FunctionMiddlewareServerNextFn<
459 TRegister,
460 TMiddlewares,
461 TServerSendContext,
462> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
463 context?: TNewServerContext
464 sendContext?: ValidateSerializableInput<TRegister, TSendContext>
465}) => Promise<
466 FunctionServerResultWithContext<
467 TRegister,
468 TMiddlewares,
469 TServerSendContext,
470 TNewServerContext,
471 TSendContext
472 >
473>
474β
475export type FunctionServerResultWithContext<
476 in out TRegister,
477 in out TMiddlewares,
478 in out TServerSendContext,
479 in out TServerContext,
480 in out TSendContext,
481> = {
482 'use functions must return the result of next()': true
483 '~types': {
484 context: TServerContext
485 sendContext: TSendContext
486 }
487 context: Expand<
488 AssignAllServerFnContext<
489 TRegister,
490 TMiddlewares,
491 TServerSendContext,
492 TServerContext
493 >
494 >
495 sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>
496}
497β
498export interface FunctionMiddlewareServerFnOptions<
499 in out TRegister,
500 in out TMiddlewares,
501 in out TInputValidator,
502 in out TServerSendContext,
503> {
504 data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>>
505 context: Expand<
506 AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext>
507 >
508 next: FunctionMiddlewareServerNextFn<
509 TRegister,
510 TMiddlewares,
511 TServerSendContext
512 >
513 method: Method
514 filename: string
515 functionId: string
516 signal: AbortSignal
517}
518β
519export type FunctionMiddlewareServerFnResult<
520 TRegister,
521 TMiddlewares,
522 TServerSendContext,
523 TServerContext,
524 TSendContext,
525> =
526 | Promise<
527 FunctionServerResultWithContext<
528 TRegister,
529 TMiddlewares,
530 TServerSendContext,
531 TServerContext,
532 TSendContext
533 >
534 >
535 | FunctionServerResultWithContext<
536 TRegister,
537 TMiddlewares,
538 TServerSendContext,
539 TServerContext,
540 TSendContext
541 >
542β
543export interface FunctionMiddlewareAfterServer<
544 TRegister,
545 TMiddlewares,
546 TInputValidator,
547 TServerContext,
548 TServerSendContext,
549 TClientContext,
550 TClientSendContext,
551> extends FunctionMiddlewareWithTypes<
552 TRegister,
553 TMiddlewares,
554 TInputValidator,
555 TServerContext,
556 TServerSendContext,
557 TClientContext,
558 TClientSendContext
559 > {}
560β
561export interface FunctionMiddlewareClient<
562 TRegister,
563 TMiddlewares,
564 TInputValidator,
565> {
566 client: <TSendServerContext = undefined, TNewClientContext = undefined>(
567 client: FunctionMiddlewareClientFn<
568 TRegister,
569 TMiddlewares,
570 TInputValidator,
571 TSendServerContext,
572 TNewClientContext
573 >,
574 ) => FunctionMiddlewareAfterClient<
575 TRegister,
576 TMiddlewares,
577 TInputValidator,
578 TSendServerContext,
579 TNewClientContext
580 >
581}
582β
583export type FunctionMiddlewareClientFn<
584 TRegister,
585 TMiddlewares,
586 TInputValidator,
587 TSendContext,
588 TClientContext,
589> = (
590 options: FunctionMiddlewareClientFnOptions<
591 TRegister,
592 TMiddlewares,
593 TInputValidator
594 >,
595) => FunctionMiddlewareClientFnResult<
596 TMiddlewares,
597 TSendContext,
598 TClientContext
599>
600β
601export interface FunctionMiddlewareClientFnOptions<
602 in out TRegister,
603 in out TMiddlewares,
604 in out TInputValidator,
605> {
606 data: Expand<IntersectAllValidatorInputs<TMiddlewares, TInputValidator>>
607 context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>
608 sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>
609 method: Method
610 signal: AbortSignal
611 next: FunctionMiddlewareClientNextFn<TRegister, TMiddlewares>
612 filename: string
613 functionId: string
614}
615β
616export type FunctionMiddlewareClientFnResult<
617 TMiddlewares,
618 TSendContext,
619 TClientContext,
620> =
621 | Promise<
622 FunctionClientResultWithContext<
623 TMiddlewares,
624 TSendContext,
625 TClientContext
626 >
627 >
628 | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>
629β
630export type FunctionClientResultWithContext<
631 in out TMiddlewares,
632 in out TSendContext,
633 in out TClientContext,
634> = {
635 'use functions must return the result of next()': true
636 context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>
637 sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>
638 headers: HeadersInit
639}
640β
641export interface FunctionMiddlewareAfterClient<
642 TRegister,
643 TMiddlewares,
644 TInputValidator,
645 TServerSendContext,
646 TClientContext,
647> extends FunctionMiddlewareWithTypes<
648 TRegister,
649 TMiddlewares,
650 TInputValidator,
651 undefined,
652 TServerSendContext,
653 TClientContext,
654 undefined
655 >,
656 FunctionMiddlewareServer<
657 TRegister,
658 TMiddlewares,
659 TInputValidator,
660 TServerSendContext,
661 TClientContext
662 > {}
663β
664export interface FunctionMiddlewareValidator<TRegister, TMiddlewares> {
665 inputValidator: <TNewValidator>(
666 inputValidator: ConstrainValidator<TRegister, 'GET', TNewValidator>,
667 ) => FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TNewValidator>
668}
669β
670export interface FunctionMiddlewareAfterValidator<
671 TRegister,
672 TMiddlewares,
673 TInputValidator,
674> extends FunctionMiddlewareWithTypes<
675 TRegister,
676 TMiddlewares,
677 TInputValidator,
678 undefined,
679 undefined,
680 undefined,
681 undefined
682 >,
683 FunctionMiddlewareServer<
684 TRegister,
685 TMiddlewares,
686 TInputValidator,
687 undefined,
688 undefined
689 >,
690 FunctionMiddlewareClient<TRegister, TMiddlewares, TInputValidator> {}
691β
692export interface RequestMiddleware<TRegister>
693 extends RequestMiddlewareAfterMiddleware<TRegister, undefined> {
694 middleware: <const TMiddlewares = undefined>(
695 middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>,
696 ) => RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares>
697}
698β
699export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any, any>
700β
701export interface RequestMiddlewareWithTypes<
702 TRegister,
703 TMiddlewares,
704 TServerContext,
705> {
706 '~types': RequestMiddlewareTypes<TRegister, TMiddlewares, TServerContext>
707 options: RequestMiddlewareOptions<TRegister, TMiddlewares, TServerContext>
708}
709β
710export interface RequestMiddlewareOptions<
711 in out TRegister,
712 in out TMiddlewares,
713 in out TServerContext,
714> {
715 middleware?: TMiddlewares
716 server?: RequestServerFn<TRegister, TMiddlewares, TServerContext>
717}
718export interface RequestMiddlewareTypes<
719 TRegister,
720 TMiddlewares,
721 TServerContext,
722> {
723 type: 'request'
724 // this only exists so we can use request middlewares in server functions
725 allInput: undefined
726 // this only exists so we can use request middlewares in server functions
727 allOutput: undefined
728 middlewares: TMiddlewares
729 serverContext: TServerContext
730 allServerContext: AssignAllServerRequestContext<
731 TRegister,
732 TMiddlewares,
733 undefined,
734 TServerContext
735 >
736}
737β
738export interface RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares>
739 extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, undefined>,
740 RequestMiddlewareServer<TRegister, TMiddlewares> {}
741β
742export interface RequestMiddlewareServer<TRegister, TMiddlewares> {
743 server: <TServerContext = undefined>(
744 fn: RequestServerFn<TRegister, TMiddlewares, TServerContext>,
745 ) => RequestMiddlewareAfterServer<TRegister, TMiddlewares, TServerContext>
746}
747β
748export type RequestServerFn<TRegister, TMiddlewares, TServerContext> = (
749 options: RequestServerOptions<TRegister, TMiddlewares>,
750) => RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext>
751β
752export interface RequestServerOptions<TRegister, TMiddlewares> {
753 request: Request
754 pathname: string
755 context: Expand<AssignAllServerRequestContext<TRegister, TMiddlewares>>
756 next: RequestServerNextFn<TRegister, TMiddlewares>
757}
758β
759export type RequestServerNextFn<TRegister, TMiddlewares> = <
760 TServerContext = undefined,
761>(
762 options?: RequestServerNextFnOptions<TServerContext>,
763) => RequestServerNextFnResult<TRegister, TMiddlewares, TServerContext>
764β
765export interface RequestServerNextFnOptions<TServerContext> {
766 context?: TServerContext
767}
768β
769export type RequestServerNextFnResult<TRegister, TMiddlewares, TServerContext> =
770β
771 | Promise<RequestServerResult<TRegister, TMiddlewares, TServerContext>>
772 | RequestServerResult<TRegister, TMiddlewares, TServerContext>
773β
774export type RequestMiddlewareServerFnResult<
775 TRegister,
776 TMiddlewares,
777 TServerContext,
778> =
779 | Promise<
780 RequestServerResult<TRegister, TMiddlewares, TServerContext> | Response
781 >
782 | RequestServerResult<TRegister, TMiddlewares, TServerContext>
783 | Response
784β
785export interface RequestServerResult<TRegister, TMiddlewares, TServerContext> {
786 request: Request
787 pathname: string
788 context: Expand<
789 AssignAllServerRequestContext<
790 TRegister,
791 TMiddlewares,
792 undefined,
793 TServerContext
794 >
795 >
796 response: Response
797}
798β
799export interface RequestMiddlewareAfterServer<
800 TRegister,
801 TMiddlewares,
802 TServerContext,
803> extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, TServerContext> {}