Mapped types build on the syntax for index signatures, which are used to declare the types of properties which has not been declared ahead of time:

A mapped type is a generic type which uses a union created to iterate through the keys of one type to create another:

type OptionsFlags<Type> = {
  [Property in keyof Type]: boolean;
};

type FeatureFlags = {
  darkMode: () => void;
  newUserProfile: () => void;
};
type FeatureOptions = OptionsFlags<FeatureFlags>;
//   ^ = type FeatureOptions = {
//       darkMode: boolean;
//   }

There are two additional modifiers which can be applied during mapping: readonly and ? which affect mutability and optionality respectively.

You can remove or add these modifiers by prefixing with or +. If you don’t add a prefix, then + is assumed.

// Removes 'optional' attributes from a type's properties
type Concrete<Type> = {
  [Property in keyof Type]-?: Type[Property];
};
type MaybeUser = {
  id: string;
  name?: string;
  age?: number;
};
type User = Concrete<MaybeUser>;
//   ^ = type User = {
//       id: string;
//       name: string;
//       age: number;

Key Remapping via as

ts

You can leverage features like to create new property names from prior ones:

You can filter out keys by producing never via a conditional type:

// Remove the 'kind' property
type RemoveKindField<T> = {
    [K in keyof T as Exclude<K, "kind">]: T[K]
};
interface Circle {
    kind: "circle";
    radius: number;
}
type KindlessCircle = RemoveKindField<Circle>;
//   ^ = type KindlessCircle = {
//       radius: number;
//   }

Further Exploration

ts
type ExtractPII<Type> = {
  [Property in keyof Type]: Type[Property] extends { pii: true } ? true : false;
};
type DBFields = {
  id: { format: "incrementing" };
  name: { type: string; pii: true };
};
type ObjectsNeedingGDPRDeletion = CreateMutable<DBFields>;