TypeScript Mapped Types: Syntax, Modifiers and Key Remapping

A mapped type builds a new object type by looping over a set of keys. { [K in keyof T]: boolean } means "for every key K of T, a property named K of type boolean":

type Features = {
  darkMode: string;
  search: number;
  export: string[];
};

// Same keys as T, every property turned into a boolean
type Flags<T> = { [K in keyof T]: boolean };

const enabled: Flags<Features> = {
  darkMode: true,
  search: false,
  export: true,
};

console.log(enabled); // { darkMode: true, search: false, export: true }
// Leaving out "export" would be error TS2741: Property 'export' is missing

Add a key to Features and Flags<Features> requires it too. Mapped types are compile-time only: they describe objects, they do not create them.

The Syntax

A mapped type has three parts: a key variable, a union of keys to iterate over, and the property type, which may use the key variable.

type MappedType = {
  [K in Keys]: PropertyType; // K takes each member of Keys in turn
};

Keys can be any union of strings, numbers or symbols. It does not have to come from keyof:

type Size = "small" | "medium" | "large";

type PriceTable = { [S in Size]: number };
// { small: number; medium: number; large: number }

const prices: PriceTable = { small: 3, medium: 4, large: 5 };

for (const size of ["small", "large"] as const) {
  console.log(size, prices[size]);
}
// small 3
// large 5

This is exactly what Record<Size, number> does; Record is a one-line mapped type. The property type can use the key: { [K in keyof T]: T[K] } copies each property type through an indexed access, and { [K in keyof T]: T[K] | null } makes every property nullable.

Modifiers: readonly and ? with + and -

A mapped type can add or remove the readonly and optional (?) modifiers on every property at once. Prefix + to add (the default when you write none) and - to remove:

type Account = {
  readonly id: number;
  email?: string;
};

type Mutable<T> = { -readonly [K in keyof T]: T[K] };
type AllRequired<T> = { [K in keyof T]-?: T[K] };
type Frozen<T> = { +readonly [K in keyof T]: T[K] };

const editable: Mutable<Account> = { id: 1 };
editable.id = 2; // allowed: readonly was removed

const complete: AllRequired<Account> = { id: 1, email: "a@b.co" };
// { id: 1 } alone would be error TS2741: Property 'email' is missing

const frozen: Frozen<{ n: number }> = { n: 1 };
// @ts-expect-error: Cannot assign to 'n' because it is a read-only property
frozen.n = 2;

console.log(editable, complete, frozen);
// { id: 2 } { id: 1, email: 'a@b.co' } { n: 2 }

The last line shows that readonly is only a compile-time rule: the assignment was reported (and suppressed here with @ts-expect-error), but the emitted JavaScript still ran it. -? does more than drop the question mark: it also removes undefined from the property type, so AllRequired<Account> rejects { id: 1, email: undefined } with error TS2322: Type 'undefined' is not assignable to type 'string'.

How Partial, Readonly, Pick and Record Are Built

The built-in utility types that reshape objects are mapped types. These are the definitions from TypeScript's own lib.es5.d.ts:

type Partial<T> = { [P in keyof T]?: T[P] };
type Required<T> = { [P in keyof T]-?: T[P] };
type Readonly<T> = { readonly [P in keyof T]: T[P] };
type Pick<T, K extends keyof T> = { [P in K]: T[P] };
type Record<K extends keyof any, T> = { [P in K]: T };

Reading them is good practice: Pick iterates over only the keys you pass, and Record ignores any source type and gives every key the same value type. Omit is not a mapped type of its own: it is Pick<T, Exclude<keyof T, K>>. The utility types reference lists them all.

Key Remapping with as

An as clause after the key changes the property name. Combined with template literal types, it can generate new names from old ones:

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type Person = { name: string; age: number };

// { getName: () => string; getAge: () => number }
const person: Getters<Person> = {
  getName: () => "Ada",
  getAge: () => 36,
};

console.log(person.getName(), person.getAge()); // Ada 36

string & K is there because keyof T may include number and symbol keys, and Capitalize only accepts strings. The intersection keeps the string keys and drops the rest.

Filtering Keys with never

If the as clause produces never for a key, that key is removed. With a conditional type you can keep or drop properties based on their type:

type DataOnly<T> = {
  [K in keyof T as T[K] extends (...args: any[]) => unknown ? never : K]: T[K];
};

class Invoice {
  constructor(public id: number, public total: number) {}
  format(): string {
    return `#${this.id}: ${this.total.toFixed(2)}`;
  }
}

// { id: number; total: number }  (format is gone)
const data: DataOnly<Invoice> = { id: 7, total: 19.5 };

console.log(data);                        // { id: 7, total: 19.5 }
console.log(new Invoice(7, 19.5).format()); // #7: 19.50

Types like DataOnly are useful for describing what survives JSON.stringify or what a form edits: the fields without the methods.

Which Modifiers Are Kept

A mapped type over keyof T for some type T is called homomorphic, and it copies each property's readonly and ? modifiers from T. A mapped type over a plain union of keys starts with no modifiers:

type Account = { readonly id: number; email?: string };

type Copy<T> = { [K in keyof T]: T[K] };
type A = Copy<Account>;
// { readonly id: number; email?: string }  (modifiers kept)

type B = { [K in "id" | "email"]: Account[K] };
// { id: number; email: string | undefined }  (email is required now)

B still has undefined in the email type, because Account["email"] includes it, but the property itself is no longer optional: { id: 1 } is rejected. This is why Partial<T> and friends map over keyof T: they keep everything they do not explicitly change.

A generic homomorphic mapped type applied to an array or tuple produces an array or tuple, not an object with numeric keys. Readonly<string[]> is readonly string[], and with type Box<T> = { [K in keyof T]: { value: T[K] } }, Box<[string, number]> is [{ value: string }, { value: number }].

Mapped Types and Runtime Code

Because a mapped type only describes an object, a function that builds such an object needs its own runtime loop. The type then describes its result:

type Validators<T> = { [K in keyof T]: (value: T[K]) => boolean };

type SignUp = { email: string; age: number };

const rules: Validators<SignUp> = {
  email: (v) => v.includes("@"), // v is string
  age: (v) => v >= 13,           // v is number
};

function validate(form: SignUp): string[] {
  const failed: string[] = [];
  for (const key of Object.keys(rules) as (keyof SignUp)[]) {
    const ok = key === "email" ? rules.email(form.email) : rules.age(form.age);
    if (!ok) failed.push(key);
  }
  return failed;
}

console.log(validate({ email: "ada@example.com", age: 36 })); // []
console.log(validate({ email: "nope", age: 9 }));             // [ 'email', 'age' ]

The callbacks get their parameter types from the mapped type (v is string in one and number in the other) without any annotation. If you came here looking for the Map class rather than type mapping, see Map in TypeScript.