TypeScript Utility Types

Utility types are generic type aliases shipped with TypeScript's standard library that accept one or more type arguments and return a transformed version of that type. They prevent you from hand-writing repetitive mapped types and keep your codebase consistent across teams.

All utility types are purely compile-time constructs — they emit zero JavaScript. They work by combining three lower-level features: mapped types ({ [K in keyof T]: ... }), conditional types (T extends U ? X : Y), and the infer keyword for extracting nested type information at the structural level.

Utility Type	Input	What It Returns	Since TS
Partial<T>	Object type	All properties made optional	2.1
Required<T>	Object type	All optional props made required	2.8
Readonly<T>	Object type	All properties read-only	2.1
Pick<T, K>	Object type + key union	Subset of T with only keys K	2.1
Omit<T, K>	Object type + key union	T minus keys K	3.5
Record<K, V>	Key union + value type	Object with keys K and values V	2.1
ReturnType<T>	Function type	Function's return type	2.8
Awaited<T>	Promise or plain type	Recursively unwrapped value type	4.5

Partial<T> makes every property in T optional by adding the ? modifier. It is most useful when writing update or PATCH functions where only a subset of fields may be present. It is shallow — nested object types are not recursively made optional.

Required<T> strips the ? modifier from every property, enforcing a fully-populated model. Use it after a factory function fills in defaults or after a validation step guarantees all fields are present.

Readonly<T> adds the readonly modifier to every property, causing the compiler to reject any mutations. Like the others, it is shallow by default.

Utility	Modifier Applied	Common Use Case	Deep?
Partial<T>	Adds ? to all props	PATCH request body, form draft state	No
Required<T>	Removes ? from all props	Post-validation model, factory output	No
Readonly<T>	Adds readonly to all props	Immutable config objects, Redux state	No

• Use Partial<Pick<T, K>> to make only a specific subset of keys optional — a common pattern for form field groups.
• The -? modifier in a custom mapped type removes optionality on a per-property basis, giving finer control than Required.

Pick<T, K> constructs a new type containing only the keys listed in the union K. It is the right tool when a function or component needs an explicit subset of a larger model, making the dependency surface clear and narrow.

Omit<T, K> does the opposite — it removes listed keys and returns everything else. Prefer Omit when the excluded set is small but the kept set is large, especially when extending third-party interfaces whose future fields you want to keep automatically.

Extract<T, U> and its counterpart Exclude<T, U> operate on union types, not object types. Extract keeps union members assignable to U; Exclude removes them. NonNullable<T> is shorthand for Exclude<T, null | undefined>.

Utility	Operates On	Example Input	Result
Pick<T, K>	Object type	Pick<User, 'id'|'name'>	{ id: number; name: string }
Omit<T, K>	Object type	Omit<User, 'password'>	User without the password field
Extract<T, U>	Union type	Extract<'a'|'b'|'c', 'a'|'c'>	'a' | 'c'
Exclude<T, U>	Union type	Exclude<'a'|'b'|'c', 'a'>	'b' | 'c'
NonNullable<T>	Union type	NonNullable<string|null>	string

Record<K, V> builds an object type whose keys are members of the union K and whose values are all of type V. It is ideal for lookup tables, enum-keyed maps, and exhaustive switch alternatives where every key must be explicitly handled.

ReturnType<T> extracts the return type of a function type. This is invaluable when you depend on a function's output shape but cannot import its return type directly — for example, with third-party library factory functions that do not export their types.

Parameters<T> extracts parameter types as a tuple. ConstructorParameters<T> does the same for class constructors. InstanceType<T> extracts the class instance type from a constructor. Pair these with spread syntax to forward arguments type-safely through wrappers.

Utility	Input Example	Resolves To
Record<'USD'|'EUR', number>	Key union + value type	{ USD: number; EUR: number }
ReturnType<typeof fetch>	Function type	Promise<Response>
Awaited<ReturnType<typeof fetch>>	Async function type	Response
Parameters<typeof parseInt>	Function type	[string, (number | undefined)?]
InstanceType<typeof Date>	Constructor type	Date

When the built-ins do not cover a pattern, build your own using mapped types, conditional types, and the infer keyword. Custom utilities follow the same generic signature as the built-ins and compose identically — they can be used as arguments to other utility types.

Common custom utilities include DeepPartial<T> (recursively optional), Mutable<T> (removes all readonly modifiers, useful in tests), and UnwrapPromise<T> (the pre-4.5 equivalent of Awaited). Keep these in a shared src/types/utils.ts file.

Custom Utility	Definition Pattern	Use Case
DeepPartial<T>	{ [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K] }	Deeply nested patch payloads
Mutable<T>	{ -readonly [K in keyof T]: T[K] }	Strip readonly in test setup
PickByValue<T, V>	Mapped + conditional type filtering by value type	Keep only string-valued props
UnwrapPromise<T>	T extends Promise<infer R> ? R : T	Pre-TS 4.5 Awaited equivalent
Nullable<T>	{ [K in keyof T]: T[K] | null }	Database row types that allow NULL

• Use the -readonly and -? modifier prefixes in mapped types to remove existing modifiers rather than add them.
• Add type-level unit tests using the tsd or expect-type package to catch regressions when TypeScript is upgraded.