Pick specific keys and reduce with same keys

I have a use-case where I need to generate an interface that inherits typing from another class with specific keys, and builds from there. I need to use this inherited-type, but also reduce data via JS into an instance of the inherited-type. Is there a way to only need to list off the keys once?

I am currently doing it like this:

interface IPrimaryType {
  key1: string;
  key2: string;
  key3: string;
  key4: string;
  key5: string;
  key6: string;
  key7: string;
}

interface ISecondaryType {
  thisDoesntMatter: string;
}

interface ITertiaryType {
  thisDoesntMatter: string;
}

interface IInheritedType extends Pick<IPrimaryType, 'key1' | 'key2' | 'key3' | 'key4' | 'key5'> {
  secondaryData: ISecondaryType;
  tirtiaryData?: ITertiaryType | null;
}

const inheritedKeys = ['key1', 'key2', 'key3', 'key4', 'key5'];

const primaryObj = {
  key1: 'value1',
  key2: 'value2',
  key3: 'value3',
  key4: 'value4',
  key5: 'value5',
  key6: 'value6',
  key7: 'value7',
};
const secondaryData = { thisDoesntMatter: '' };
const tirtiaryData = { thisDoesntMatter: '' };

let inheritedObj = inheritedKeys.reduce(
  (acc, key: string) => ({ ...acc, [key]: (primaryObj as any)[key] }),
  {} as IInheritedType
);
inheritedObj.secondaryData = secondaryData;
inheritedObj.tirtiaryData = tirtiaryData;

You can't derive values like inheritedKeys from types like 'key1' | 'key2' | 'key3' | 'key4' | 'key5', since the type system is erased upon compilation. But you can do the reverse and derive types from values. Like this:

const inheritedKeys = [
'key1',
'key2',
'key3',
'key4',
'key5',
] as const;
type InheritedKeys = typeof inheritedKeys[number];
// type InheritedKeys = "key1" | "key2" | "key3" | "key4" | "key5"

You have to use a const assertion to ask the compiler to keep track of the literal types of the initializer of inheritedKeys. Otherwise inheritedKeys would be of type string[] and the individual elements like "key3" would be forgotten.

Once you do that, the typeof type query operator can be used to get the type of the inheritedKeys variable, and by indexing into that with number you get the type of the values at numeric indices of inheritedKeys; that is, the element type.

And so InheritedKeys is the union of the literal types of the elements. And you can use InheritedKeys inside your definition of IInheritedType:

interface IInheritedType extends Pick<IPrimaryType, InheritedKeys> {
secondaryData: ISecondaryType;
tertiaryData?: ITertiaryType | null;
}

Playground link to code