Getting class method argument types from indexed generic type

I have a class with some functions as well as a non-function property:

class Example {
    methodA(param1: string, param2: number) {}
    methodB(): string {}
    methodC(param1: boolean, param2: number): number {}
    prop1: string = '';
}

I want to write a method that would receive the class method name as a parameter and the corresponding method's arguments as the remaining parameters and also return the same data type as the specified class method. It would look like this:

call('methodA', 'a string', 123); // If the method has a void return type
let value = call('methodC', true, 456) // If the method has a non-void return type;

I can fetch the method names using keyof Example as follows:

function call<K extends keyof Example>(functionName: K) {}

However, I am stuck at getting the corresponding method arguments and return type. My attempt has been as follows:

function call<K extends keyof Example>(functionName: K, ...args: Parameters<Example[K]>): ReturnType<Example[K]>

When I do this, I get an error stating that Type 'Example[K]' does not satisfy the constraint '(...args: any) => any'.

When I use the indexed type on its own and without using the rest parameters

function call<K extends keyof Example>(functionName: K, args: Example[K])...

I can see that the correct function signature is expected as the args parameters, so I assumed that this function type satisfy the constraint expected by the Parameters<> utlity type. I have a similar issue with the ReturnType utility type.

How could I get Example[K] to work as (...args: any) => void?

You want to get just the keys of Example whose property values are callable. There is no built-in utility type that does this for you (see microsoft/TypeScript#48992 for the relevant feature request) but you can define your own in a number of ways. Here's one way, using key remapping:

type KeysMatching<T extends object, V> = keyof { 
  [K in keyof T as T[K] extends V ? K : never]: any 
}

So KeysMatching<T, V> will give you just those keys of T whose property values are assignable to V. And so you can get just the callable keys of Example like this:

type CallableKeys = KeysMatching<Example, (...args: any) => any>;
// type CallableKeys = "methodA" | "methodB" | "methodC"

Now you can then define call() in terms of CallableKeys:

declare function call<K extends CallableKeys>(
    functionName: K, ...args: Parameters<Example[K]> // okay
): ReturnType<Example[K]>;

and the error goes away.

This approach has the advantage of automatically updating if more non-function properties are added to the Example class.

Playground link to code

I have found the solution to my issue, the problem was that the class I was using also contained public variables/properties and these are picked up by the keyof Example type. When using this in a Parameters<> type, it throws an error because not all the class properties are callable.

The solution was to enclose the keyof Example inside an Exclude<> utility type and specify which keys need to be excluded.

For example, if the class was declared as follows:

class Example {
    public prop1: string = '';

    methodA(param1: string, param2: number) {}
    methodB(): string {}
    methodC(param1: boolean, param2: number): number {}
}

then callable keys can be obtained using Exclude<keyof Example, 'prop1'> resulting in Parameters<Exclude<keyof Example, 'prop1'>> being valid.