How to make TS work with type groups?

Question

typescript

There is a function:

const f = (someObj: T1 | T2, someEnum: typeof E1 | typeof E2): string => {
    return someObj[someEnum.a];
};

It must accept either T1 + E1, or T2 + E2.
Making such a restriction is not a problem and it is done (code below), BUT in strict mode someObj[someEnum.a]an error (ts(7053)) comes out in all the options that I tried (in particular, overloading and arguments in the form of an object).

Mistake:

Element implicitly has an 'any' type because expression of type 'E1.a | E2.a' can't be used to index type 'T1 | T2'.
  Property '[E1.a]' does not exist on type 'T1 | T2'.(7053)

Sandbox Link: https://www.typescriptlang.org/play?jsx=0#code/KYO...

The same code, if anyone is too lazy to climb into the sandbox

enum E1 {
  a = 'a1',
}
enum E2 {
  a = 'a2',
}
type T1 = {
  [key in E1]: string;
};
type T2 = {
  [key in E2]: string;
};

{
  const f = (someObj: T1 | T2, someEnum: typeof E1 | typeof E2): string => {
    return someObj[someEnum.a]; // ts(7053)
  };
}
{
  function f(someObj: T1, someEnum: typeof E1): string;
  function f(someObj: T2, someEnum: typeof E2): string;
  function f(someObj: T1 | T2, someEnum: typeof E1 | typeof E2): string {
    return someObj[someEnum.a]; // ts(7053)
  }
}
{
  type TT =
    | { someObj: T1; someEnum: typeof E1 }
    | { someObj: T2; someEnum: typeof E2 };
  const f = (tt: TT): string => {
    return tt.someObj[tt.someEnum.a]; // ts(7053)
  };
}

Is there a way to make TS understand that it can't be there T1 + E2or T2 + E1?

PS: it is not an option to do a type check inside a function, because object T1/T2can be empty.

Answer 1

Judging by the activity, there is no adequate solution. I had to resort to minimal crutches:

function f(someObj: T1, someEnum: typeof E1): string;
function f(someObj: T2, someEnum: typeof E2): string;
function f(someObj: T1 | T2, someEnum: typeof E1 | typeof E2): string {
    const typedSomeObj = someObj as T1 & T2;
    return typedSomeObj[someEnum.a];
}

Answer 2

It can be like this:

function f<X extends { [index: string]: string }>(someObj: X, someEnum: keyof X): string  {
    return someObj[someEnum];
}

https://www.typescriptlang.org/play?jsx=0#code/C4T...
Or is it necessary to limit ourselves to types T1, T2?

Answer 3

const f = <T extends T1 | T2>(someObj: T, someEnum: T extends T1 ? typeof E1 : typeof E2) => {
  return (someObj as T1 & T2)[someEnum.a];
};