Support for RequiredExactlyOne

[haejunejung]

This introduces support for RequiredExactlyOne.

Sometimes, we want to enforce that only one property from a set of properties can be used at a time.

For example:

type A = { a: string };
type B = { b: string };

function doSomething(input: A | B) {
  // do something
}

In this case, the union type A | B allows us to pass either A or B, but it also allows both properties (a and b) to coexist, which might not be what we want.

To ensure that exactly one property is used, we can use RequiredExactlyOne.

type Example = {
	a: () => string;
	b: () => string;
};

const example: RequiredExactlyOne<Example, 'a' | 'b'> = {
	// Adding both `a` and `b` would cause a compile error.
	b: () => { console.log(1); }
};

RequiredExactlyOne ensures that only one of the specified properties is present, preventing potential conflicts when multiple properties could be passed at the same time.