Typescript: Omitting translated properties

I have interfaces that can be translated - they have the nameDe and nameFr properties for example. Currently I'm trying to build a function that returns the object with name only in the users language.

This is what I have so far - it works for the translated properties but not the "non-translated":

type TranslatedObject<T> = {
  [K in keyof T as K extends `${infer Name}De` ? `${Name}` : never]: T[K extends `${infer Name}De` ? K : never];
};

interface Car {
  nameDe: string,
  nameFr: string,
  price: number
}

const carWithUserLang: TranslatedObject<Car> = {
  name: 'Make Model Trim',
  price: 50000 // --> Type '{ name: string; price: number; }' is not assignable to type 'TranslatedObject<Car>'.
}

How can I make this run?
Stackblitz: https://stackblitz.com/edit/typescript-h7ghdn?file=index.ts&view=editor

My assumption is that you want TranslatedObject<T> to strip "De" and "Fr" off of the ends of key names, if they exist, and otherwise leave them alone. If so then this is purely a key remapping operation that doesn't change the property value types. Like this:

type TranslatedObject<T> = {
  [K in keyof T as K extends `${infer Name}${"De" | "Fr"}` ? Name : K]: T[K];
};

It uses a conditional type inference within a template literal type to strip off any "De" or "Fr" suffix. The check K extends `${infer Name}${"De" | "Fr"}` tries to match K to something that starts with some arbitrary string and ends in "De" | "Fr"; if it succeeds, then Name is inferred to be that arbitrary initial string. So then the resulting key type evaluates to Name if the parsing succeeded, or K if it failed.

That results in the type you were expecting:

interface Car {
  nameDe: string,
  nameFr: string,
  price: number
}

type TranslatedCar = TranslatedObject<Car>;
/* type TranslatedCar = {
    name: string;
    price: number;
} */

Note that there are some interesting edge cases, like what happens if your two keys have different value types:

type Weird = TranslatedObject<{
  oopsDe: string;
  oopsFr: number;
  other: boolean;
}>

/* type Weird = {
    oops: string | number; // <-- becomes union
    other: boolean;
} /

That might be what one would expect, or it might not. The point is that one should always thoroughly test against one's use cases.

Playground link to code