Is it possible to create a generic type to use in another types?

I have this function:

function stackPlayer(stack){

}

The stack parameter can only be one of the following:

1. a function that takes req, res, next as arguments.
2. a function that takes req, res, next as arguments, and returns a function that takes req, res, next as arguments.
3. a function that takes req, res, next as arguments, and returns an array of functions that takes req, res, next as arguments.
4. an array of functions that takes req, res, next as arguments.

Practical example:

// the following is allowed to used as an argument:
(req, res, next) => {} // or
(req, res, next) => (req, res, next) => {} // or
(req,res,sNext) => [(req,res,sNext)=>{}] // or
[(req,res,sNext)=>{}]

In order to type the parameter of the function, I wrote the following, which looks quite complex to read and understand:

type Stack =
  | ((req: Request, res: Response, next: NextFunction) => {})
  | ((
      req: Request,
      res: Response,
      next: NextFunction
    ) => (req: Request, res: Response, next: NextFunction) => {})
  | ((
      req: Request,
      res: Response,
      next: NextFunction
    ) => { (req: Request, res: Response, next: NextFunction): void }[])
  | { (req: Request, res: Response, next: NextFunction): void }[]

function stackPlayer(stack: Stack){

}

How can I simplify this long long type? can I create a generic type and use it for another type, ex:

type Smiddleware = <T = void>(req: Request, res: Response, next: NextFunction) => T
type Stack = Smiddleware<void> | Smiddleware<Smiddleware> | Smiddleware<Smiddleware[]> | Smiddleware[]

This looks much better, but it's of course not valid.

You can move the generic parameter to the Smiddleware type instead of the function inside.

Something like this:

type Smiddleware<T> = (req: Request, res: Response, next: NextFunction) => T
type Stack = Smiddleware<{}> | Smiddleware<Smiddleware<{}>> | Smiddleware<Smiddleware<void>[]> | Smiddleware<void>[]

Then you can use other type instead of {} or void, depending on what the function returns.

For example:

type Stack = Smiddleware<{}> | Smiddleware<number> | Smiddleware<Smiddleware<string>>;

Regarding your question on the comment, if you want to be able to use Smiddleware without specifying the type, you can add a default value for the generic parameter:

type Smiddleware<T = void> = ... // same as before