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.

Das Issue nennt keine Quelldatei, keinen Test und keinen Einstiegspunkt der Implementierung und sagt, dass eine minimale Reproduktion noch entwickelt wird. Beginne damit, die Beispiele für generische Callables in einen Compiler-Test zu überführen; als erledigt würde eine zuverlässige Möglichkeit gelten, Callable-Typparameter zu erkennen oder beizubehalten, oder eine dokumentierte Lösung.

Vom Indexierungsmodell aus dem Issue-Text verfasst.