Union type mapped to an object with single key

Is there a way to create an object type with a single key that is one of the strings from the string union type?

Example:

type Key = "a" | "b" | "c"

const result = {
  a: "hello there"
}

const result2 = {
  b: "General Kenobi"
}

const result3 = {
  c: 2137
}

// All types above should be correct after mapping

const wrongType = {
  a: "hello there";
  b: "General Kenobi";
}

const wrongType2 = {};

// Those should be wrong because either it's not a single-key object, or it doesn't have keys at all

You can achieve this using mapped types.

type Keys = "a" | "b" | "c";

type T = {
  [key in Keys]: { [k in key]: unknown } & {
    [k in Exclude<Keys, key>]?: never;
  };
}[Keys];

So, we generate a type that is a union of three objects where each object explicitly states that if one property is present others should not be present. So, the generated type is the following:

type T =
  | { a: unknown; b?: undefined; c?: undefined }
  | { b: unknown; a?: undefined; c?: undefined }
  | { c: unknown; a?: undefined; b?: undefined };

<br>

NOTE: Just doing the following:

type T = {
  [key in Keys]: { [k in key]: unknown }
}[Keys];

would not work because Unions without discriminant properties do not perform excess property checking.

One way to do that is using the library called ts-xor:

import { XOR } from 'ts-xor'

let test: <A, B>
type Key = XOR<{ a: string }, XOR<{ b: string }, { c: string }>>

// OK!
const result: Key = {
  a: "hello there"
}

// OK!
const result2: Key = {
  b: "General Kenobi"
}

// OK!
const result3: Key = {
  c: 2137
}

// Error due to no matching type
const wrongType: Key = {
  a: "hello there",
  b: "General Kenobi",
}

// Also errors
const wrongType2: Key = {}