Enum value as function parameter mapped to specific return type

I have created a small example of a problem I'm experiencing. I want the get function to take a enum parameter, and have the return value of the function be dependant on that enum value. I'm trying to map the enum value to it's type in a mapped type, but I'm not having any luck.

The code below doesn't work - it seems like it believes the mapping type to be a union type.

type T1 = { name: string }
type T2 = { age: number }
enum Type { TypeOne, TypeTwo }

const get = <T extends Type>(type: T): {
    [Type.TypeOne]: T1
    [Type.TypeTwo]: T2
}[T] => type === Type.TypeOne ? { name: 'Brian' } : { age: 42 }

I get the error message on the last line:

Type '{ name: string; } | { age: number; }' is not assignable to type '{ 0: T1; 1: T2; }[T]'.
  Type '{ name: string; }' is not assignable to type '{ 0: T1; 1: T2; }[T]'.
    Type '{ name: string; }' is not assignable to type 'T1 & T2'.
      Property 'age' is missing in type '{ name: string; }' but required in type 'T2'.ts(2322)

Fiddle link

Any suggestions?

TypeScript currently can't use control flow analysis to affect generic type parameters. So while checking type === Type.TypeOne will have an effect on the apparent type of type, the generic type parameter T will stubbornly remain unaffected.

It might seem "obvious" that checking type === Type.TypeOne should narrow T from T extends Type to T extends Type.TypeOne, but in general this would be incorrect. After all, T might be the full union type Type. For a call signature like <T extends Type>(type1: T, type2: T) => void, it would be dangerous to assume that checking type1 === Type.TypeOne would mean that type2 === Type.TypeOne. So some other approach is necessary, possibly as described in the open feature request at microsoft/TypeScript#33014. But for now, nothing like this is implemented.

Until and unless support for that is added, the way I'd approach implementing a generic function that returns an indexed access type is to actually index into an appropriately-typed object with the appropriate index. For your example that could look like:

const get = <T extends Type>(type: T): {
    [Type.TypeOne]: T1
    [Type.TypeTwo]: T2
}[T] => ({
    [Type.TypeOne]: { name: 'Brian' },
    [Type.TypeTwo]: { age: 42 }
}[type]);

If you really need to, you could even write this with getters so that the object lazily computes only the member you are accessing:

const get = <T extends Type>(type: T): {
    [Type.TypeOne]: T1
    [Type.TypeTwo]: T2
}[T] => ({
    get [Type.TypeOne]() { return { name: 'Brian' } },
    get [Type.TypeTwo]() { return { age: 42 } }
}[type]);

For the example code that wouldn't matter much, but you might want to do this if the original function has side effects or if pre-computing every possible return value is too expensive.

Playground link to code