typescript generic to make object have keys ONLY (but not necessarily all) from list of names

Question

What i want

I have a type with known values

type Possibilities = "a" | "b" | "c"

And want to be able to create object that can only have keys that belongs to that type, but not necessarily all of then.

And also prevent each prop's type from outputing as string | undefined

As it is meant to be used on constants, that have fixed values. And TS can already infer proper typing:

So, it should accept:

const mine = {
    a: "this",
    b: "and",
    c: "that"
}
const yours = {
    b: "it"
}

But should not:

// not known key ( 'x' )
const theirs = {
    a: "these",
    x: "those"
}
// preferably - empty object
const noOnes = {}

---

I've tryed:

• If i do one of bellow

  const mine: Record<Possibilities, string>;
  const mine: {[key in Possibilities]: string};
  

  it says the obj must have all the keys. Wrong.

• If i do one of

  const mine: Partial<Record<Possibilities, string>>;
  const mine: {[key in Possibilities]?: string};
  

  it allow me to set only some, however, types gets out as string | undefined. Even if "casting" object as const.

• Pick<> or Omit<>, for every single "instance" created, makes the desired result, but it's a pain in the ass, and kind of repeating myself (need to write "a", "b"... on type and again on value). Also, at least here, Omit<> is not even auto-completing the possible values. Making it even harder and/or error prone when using most of possibilities, by needing to pick a lot or omit 'blindly'.

I got a feeling that the solution is somewhere close by using a generic that may extend the type... But couldn't figure it out.

--- EDIT ---

@tokland comment took me to an "almost there" solution

type AtLeastOne<T, U = {[K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U]

type Possibilities = "a" | "b" | "c"

let mine: AtLeastOne<Record<Possibilities, string>>;

This enforces the object to have a, b or c prop. Forbids it to have unknown props. And correctly outputs prop's type as not "possibly undefined"

But it breaks apart when multiple allowed props are set

Answer 1

I think this is what you are trying to accomplish:

// Here you can include all the keys you want
enum Possibilities {
    a = "a",
    b = "b",
    c = "c",
}

type OtherType = {
    [key in Possibilities]?: {}; // here the sign ? allows you to set the keys as optional
}
// valid
let A: OtherType = {
    a: {}
}
// valid
let C: OtherType = {
    a: {},
    b: {},
    c: {},
}

// also valid
let B: OtherType = {}

you can check this for more explanation about the topic

Answer 2

With TypeScript 4.9 and above you can achieve this with the satisfies operator.

This allows you to ensure a value satisfies a type, without applying that type to it.

const mine = {
  a: 'this',
  b: 'that',
} satisfies Partial<Record<Possibilities, string>>;

If you use this with as const, you can even get the exact string values as their type, rather than just string, and make all the keys readonly.

E.g. in the below example the type of mine.a is 'this', and it cannot be modified.

const mine = {
  a: 'this',
  b: 'that',
} as const satisfies Partial<Record<Possibilities, string>>;

Answer 3

You should be able to use Conditional Types for this:

type Possibilities = "a" | "b" | "c"

type OnlyPossibilities<P extends string | number | symbol, T> = T extends {
  [key in P]?: any
} ? T : never

type Foo = OnlyPossibilities<Possibilities, {
  a: number
}>

type Bar = OnlyPossibilities<Possibilities, {
  d: number
}>

(Link to the TS Playground)

Here I am declaring a helper type which accepts both the possibilities, P, and the type you want to check, T. Foo will correctly be of type:

type Foo = { a: number }

...but Bar will be:

type Bar = never

thus "not allowing any values".

You can also get rid of P, I just used it to make the helper type customizable:

type Possibilities = "a" | "b" | "c"

type OnlyPossibilities<T> = T extends {
  [key in Possibilities]?: any
} ? T : never

If you have any banned, you should be able to use unknown instead.