Is your feature request related to a real problem or use-case?

I have in my project a situation I simplified to:

enum FooEnum {
    ONE = 'ONE'
}

enum BarEnum {
    TWO = 'TWO'
}

type A = { x: FooEnum }
type B = { x: BarEnum, y: string }
type C = { z: number }

type AllKeys = keyof (A | B | C)

Where I want all the keys from my union, so 'x' | 'y' | 'z'

Now, currently that gives me a never, as the keys never match.

Describe a solution including usage in code example

In order to get those keys, I thought of trying to turn this Union into a Intersection by using:

import type { UnionToIntersection } from 'utility-types'

enum FooEnum {
    ONE = 'ONE'
}

enum BarEnum {
    TWO = 'TWO'
}

type A = { x: FooEnum }
type B = { x: BarEnum, y: string }
type C = { z: number }

type AllKeys = keyof UnionToIntersection<A | B | C>

But that also doesn't work, giving me string | number | symbol, as the intersection is also never.

But if I give them a common base type, across all of them, then it works, which came out as:

import type { UnionToIntersection } from 'utility-types'

enum FooEnum {
    ONE = 'ONE'
}

enum BarEnum {
    TWO = 'TWO'
}

type A = { x: FooEnum }
type B = { x: BarEnum, y: string }
type C = { z: number }

type AllUnionKeys<U> = keyof UnionToIntersection<Partial<U>>
type AllKeys = AllUnionKeys<A | B | C>

I tried to think about an alternative that feels less hacky, but came up short.

Who does this impact? Who is this for?

The impact is limited to anyone that opts to use it, and its for anyone that wants all the possible keys in an union.

I am willing to open a PR for this, but wanted first to see if the concept would be accepted.