Way to detect whether a callable has type parameters

### 🔍 Search Terms

conditional type detect callable type parameter

### ✅ Viability Checklist

- [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [x] This wouldn't change the runtime behavior of existing JavaScript code
- [x] This could be implemented without emitting different JS based on the types of the expressions
- [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [x] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [x] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

### ⭐ Suggestion

I'm looking for some way to detect if a callable type is generic and has type parameters.

LLMs are hallucinating an answer that would be nice if it worked:

```js
type HasTypeParameter any> =
T extends (...args: any[]) => any ? true : false;
```

### 📃 Motivating Example

I have a utility type that wants to map the return value of a callable. However because as far as I know it's not possible to map a type-parametrized callable keeping its parametrization, we prefer to bail out in this case and maintain the original type.

Roughly it looks like

```js
type MappedCallable = HasTypeParameter extends true
? T
: (...args: Parameters) => MappedResult>;
```

### 💻 Use Cases

I can achieve this detection in some case where the type of the callable is incompatible with a mapped callable were its type parameters inferred as `any`.

```js
type LimitedHasTypeArgument any> =
((...args: Parameters) => ReturnType) extends T ? false : true
```

However this doesn't work in some more complex cases (still trying to get a minimal repro).

I cannot think of other workarounds, which is forcing us to forego the result type mapping completely.

Of course having a way to keep the callable type-parametrization in the result mapping would be even better.

The specific use case is to map all callable in the result, including object methods, to callables returning a promise, while maintaining other parts of their signature.

El issue no indica ningún archivo fuente, prueba ni punto de entrada de la implementación, y dice que todavía se está desarrollando una reproducción mínima. Empieza reduciendo los ejemplos de callables genéricos a una prueba del compilador; se consideraría completado si hubiera una forma fiable de detectar o conservar parámetros de tipo callable, o una resolución documentada.

Escrito por el modelo de indexación a partir del texto del issue.