Typescript extract keys from an object where each key value has a specific property

I have a read-only object that is used to represent the stats for my game like so:

const STATS = {
  gp: {
    name: "Games Played",
    slug: "GP",
  },
  minp: {
    name: "Minutes Played",
    slug: "MINP",
  },
  minpg: {
    name: "Average Minutes Per Game",
    slug: "MINPG",
    generated: {
      // ...properties,
    },
  },
  avgrec: {
    name: "Average Receptions",
    slug: "avgrec",
    generated: {
      // ...properties,
    },
  },
} as const;

I want to extract all the keys from the object that have a generated property set. That way I can use this key in some of my utility functions. Thus, I tried the below:

type GeneratedStatKeys = {
  [I in keyof typeof STATS]: typeof STATS[I]["generated"] extends undefined
    ? never
    : typeof STATS[I];
}; // "minpg" | "avgrec"

GeneratedStatKeys should be a union type of strings, the extracted keys of STATS. However, Typescript is throwing an error "Type '"generated"' cannot be used to index type STATS"

This makes sense, so I annotated the STATS object to be:

const STATS: Record<string, Stat> = {
//...stats
} as const;

where Stat is:

interface Stat {
  name: string;
  slug: string;
  generated?: {
  //...props
  };
}

This works, however, GeneratedStatKeys type is then string.

What is the workaround? I could just manually create a string union type for the generated keys but was wondering if this could be "automated".

You can't index into a type with a key unless it's a known key of the type. Since some of the properties of typeof STATS don't have a generated key, you can't index into an arbitrary property that way. Instead you could check if the property has that key by using the keyof operator:

type GeneratedStatKeys = {
  [K in keyof typeof STATS]: "generated" extends keyof typeof STATS[K] ? K : never
}[keyof typeof STATS]
// type GeneratedStatKeys = "avgrec" | "minpg"

Once you did this check you could do the indexed access (e.g., "generated" extends keyof Foo ? Foo[K] : ...) but in your case you just want the key, not the property type.

Playground link to code