Mapped Types

Mapped types create new types by transforming every property of an existing type. They're TypeScript's equivalent of Array.map() but for type-level properties.

Basic Syntax

A mapped type iterates over keys and produces a new type for each:

type Readonly<T> = { readonly [K in keyof T]: T[K] };

• keyof T produces a union of T's property names
• K in iterates over each key in the union
• T[K] is an indexed access type — the type of property K on T
• The result has the same keys as T but with readonly added

Property Modifiers

Mapped types can add or remove readonly and ? (optional) modifiers:

// Add readonly to all properties
type Readonly<T> = { readonly [K in keyof T]: T[K] };
 
// Make all properties optional
type Partial<T> = { [K in keyof T]?: T[K] };
 
// Remove optional (make all required)
type Required<T> = { [K in keyof T]-?: T[K] };
 
// Remove readonly
type Mutable<T> = { -readonly [K in keyof T]: T[K] };

The - prefix removes a modifier, + adds it (the default). Required<T> uses -? to strip optional markers from every property.

Key Remapping with as

TypeScript 4.1 added key remapping to filter, rename, or compute new keys:

// Filter: keep only string-valued properties
type StringProps<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K]
};
 
// Rename: prefix all keys with 'get'
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};

Mapping a key to never removes it from the result — this is how you implement filtering. Template literal types in the as clause enable dynamic key renaming.

Built-in Mapped Utility Types

TypeScript's standard library includes several mapped types:

• Partial<T> — all properties optional
• Required<T> — all properties required
• Readonly<T> — all properties readonly
• Record<K, V> — object with keys K and values V: { [P in K]: V }
• Pick<T, K> — select subset of properties: { [P in K]: T[P] }
• Omit<T, K> — remove properties (implemented as Pick<T, Exclude<keyof T, K>>)

Understanding that these are mapped types helps debug and extend them.

Mapping Over Unions

You can map over any union, not just keyof T:

type EventHandlers = {
  [K in 'click' | 'focus' | 'blur']: (event: Event) => void
};

Record<K, V> is the built-in version of this pattern.

Recursive Mapped Types

Combine mapped types with conditional types for deep transformations:

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K]
};

This recursively makes every nested property readonly — useful for immutable state patterns.

Preserving Modifiers

By default, mapped types preserve the optional and readonly modifiers of the original type. If the original property is optional, the mapped property is optional too (unless you explicitly change it with -? or -readonly).

Key Interview Distinction

Mapped types iterate over keys with [K in keyof T] to create new types — they're the mechanism behind Partial, Required, Readonly, Pick, and Record. Modifiers (+/- readonly and ?) control property attributes. Key remapping (as clause) enables filtering (map to never) and renaming (template literal types). Recursive mapped types with conditional types enable deep transformations.