Typescript: union of interface properties names when interface inherits

We have that code:

export interface SingleAction {
//...
}

export interface Actions {
    [key: string]: SingleAction
}

//

export interface ExampleActions extends Actions {
    testAction: {
        //...
    }

    testAction2: {
        //...
    }
}

Abstract type Actions is just for guarding shapes of real ActionList like types (for example ExampleActions)

Now we need type that is union of all properties names in ExampleActions:

// expecting Test to be "testAction" | "testAction2" but instead it's string
type Test = keyof ExampleActions; 

const a: Test = "gfhgfh"; // valid, but should require only "testAction" | "testAction2"

When I drop extends Actions in line export interface ExampleActions extends Actions { then it works as expected.

How to make it happen without droping it?

Why I need it?

I want to some class knows allowed parameteres in some method call, like this:

class ActionsManager<CALLABLE_ACTIONS extends Actions> {
    callAction(name: keyof CALLABLE_ACTIONS) {
        //...
    }
}

const am = new ActionsManager<ExampleActions>();

am.callAction("testAction"); //good
am.callAction("testAction2"); //good
am.callAction("anotherAction"); //wrong, there is no property "anotherAction" in "ExampleActions" interface

May be related:

https://github.com/microsoft/TypeScript/issues/24274

https://github.com/DanielXMoore/Civet/issues/271

looks like it isn't possible right now? But there is keyword satisfies that some people consider to introduce to Typescript syntax.

Ideally the time to pull this information out of ExampleActions is before you mix it with Actions via interface extension and before these known keys are absorbed into string:

interface BaseExampleActions {
    testAction: {}
    testAction2: {}
}

interface ExampleActions extends Actions, BaseExampleActions { }

type Test = keyof BaseExampleActions;
const a: Test = "gfhgfh"; // error!

But if you already have ExampleActions defined that way and really need to extract the known keys and ignore the index signature, then you can use key remapping in mapped types to do it:

type KnownKeys<T> = keyof {
    [K in keyof T as {} extends Record<K, any> ? never : K]: any
}

Here what we're doing is checking each key K in keyof T to see if it's one of the valid index signature key types like string, number, symbol or a pattern template literal type such as `abc${string}def`. The only way I know of to do that is to test for whether an object with that key type is allowed to be empty. A literal type like "a" fails that test, because {} cannot be assigned to {a: any}. But a type like string passes, because {} can be assigned to {[k: string]: any}.

Anyway, let's test it out:

type Test = KnownKeys<ExampleActions>;
// type Test = "testAction" | "testAction2"

Looks good. KnownKeys<ExampleActions> returns just "testAction" | "testAction2" and the string part is discarded.

Playground link to code