The following piece of code does exactly what I intend to know with one caveat, I would like to avoid having to explicit the generic it needs.
type EventGroup = {
actions: "run" | "save"
other: "bla"
}
export type EventType<T extends keyof EventGroup> = `${T}/${EventGroup[T]}`
const t: EventType<"actions"> = "actions/run"
I would like Typescript to infer that:
`actions/run` -> valid
`actions/save` -> valid
`actions/bla` -> NOT valid
`other/bla` -> valid
Which is what this code does but with an explicit generic.
You can do that with a mapped type you then take a union of the values from:
export type EventType = {
[Key in keyof EventGroup]: `${Key}/${EventGroup[Key]}`
}[keyof EventGroup];
Testing the validity of the type:
const t1: EventType = "actions/run"; // valid
const t2: EventType = "actions/save"; // valid
const t3: EventType = "actions/bla"; // NOT valid
const t4: EventType = "other/bla"; // valid
There are two parts to that, first the mapped type:
type EventType = {
[Key in keyof EventGroup]: `${Key}/${EventGroup[Key]}`
}
which evaluates as:
type EventType = {
actions: "actions/run" | "actions/save";
other: "other/bla";
}
Then we use [keyof EventGroup] on the end to extract just the values of actions and other as a union.