Built-in Utility Types

ReturnType<typeof createUser> gives the type. In a type position, typeof turns the value createUser into its function type, which ReturnType then unwraps. ReturnType<createUser> fails because createUser is a value, not a type.

Partial<T> makes every property of T optional, Required<T> makes every property mandatory, and Readonly<T> makes every property read-only. All three keep T's keys and property types, flip one modifier, and disappear when the code is compiled to JavaScript.

Pick<T, K> builds an object type containing only the properties of T named in K; Omit<T, K> contains every property of T except those. Deriving keeps one source of truth, so editing T updates both types automatically.

Record<K, V> builds an object type whose keys come from K and whose values are all V. It is defined as the mapped type { [P in K]: V }, so a string key produces an open index signature while a union of literals produces exactly those required properties.

Exclude<T, U> is T extends U ? never : T and Extract<T, U> is T extends U ? T : never. Because T is a bare type parameter, the conditional is applied to each union member separately and the results are unioned.

An async function's return type is Promise<T>, so ReturnType gives Promise<{...}>, not the object. Awaited<T> unwraps it: Awaited<ReturnType<typeof fetchUser>> is the user shape. Awaited recurses through nested promises and passes non-promise types through unchanged.

Both utilities map only over Config's top-level keys. Partial<Config> makes name and db optional but leaves host and port inside db required, and Readonly<Config> marks the db property read-only without touching the object it points to.

Their key parameters are constrained differently. Pick declares K extends keyof T, so a typo fails the constraint. Omit declares K extends keyof any, accepting any property name, then subtracts it from T's keys — subtracting a key that is absent simply removes nothing.

A union of literals is a finite key set, so Record generates one required property per member. Adding a member generates one more required property, and every existing lookup object is now missing it. Record<string, string> is an open index signature that requires no key at all, so nothing can be missing.

Record<string, number> declares an open key set, so the compiler types every lookup as number whether or not the key exists — it models permitted keys, not present ones. Model absence explicitly instead: Record<string, number | undefined>, or a Partial Record over a finite key union.

Use Extract with a partial shape as the filter: Extract<Action, { type: 'add' }> is the add variant, and Extract<Action, { type: 'add' }>['payload'] is its payload type. Nothing is duplicated, so the types follow the union.

Use ConstructorParameters<typeof HttpClient> for the argument tuple and InstanceType<typeof HttpClient> for the instance. InstanceType<HttpClient> fails because the bare class name already means the instance type; the constructor side is reached only through typeof HttpClient.

Declare the wrapper as (...args: Parameters<typeof sendEmail>) and spread args into the call. Parameters<typeof sendEmail> is the labelled tuple [to: string, subject: string, body: string], so adding or reordering parameters updates the wrapper automatically.

Readonly<T> is a type operator applied to an existing type: it marks the top-level properties read-only and leaves the property types alone. A const assertion applies to a literal expression, infers the narrowest literal types, and makes the whole literal deeply read-only.

For a string key they produce the identical type — Record<string, User> expands to that index signature. They differ as tools: Record is a generic alias whose key set can be a union, enum or computed type and which composes with other utilities, while an index signature is a declaration form that can sit inside an interface next to named members.

Exclude puts no constraint on its second type argument, so any type is a legal filter. The misspelled literal matches no member, nothing is removed, and the result is the full Status union. Constrain the filter yourself with a helper such as type ExcludeStrict<T, U extends T> = Exclude<T, U>.

For an overloaded function both utilities see only the last overload signature, silently discarding the others. For a generic function the type parameters are already instantiated — unconstrained ones become unknown — so the caller's argument type never reaches the return type.

Partial<User> permits every field to be patched, including identity fields that must never change; it accepts an empty object; and it accepts an explicit undefined for any property, which the spread then copies over a real value, leaving a User whose required field is undefined while the type still claims it is present.

Omit applies to the union as a whole, not member by member. It computes keyof Shape, which is only the keys every member shares, then picks from that — so member-specific properties vanish. A distributive wrapper that maps Omit over each member preserves the variants.

Deriving is wrong when the two types are separate contracts that merely look alike. Omit couples your wire format to storage, fails open when a field is renamed, and never errors on a stale key — so a public contract is better declared explicitly and checked against the entity.

Required<{ a?: number }> is { a: number } and Required<{ b: number | undefined }> is unchanged at { b: number | undefined }. Required removes the optional marker, and only where it removes one does it also drop undefined from that property's type.

Declare the type wherever it is a contract others depend on: a package's public API, a cross-team boundary, a persisted or wire shape. Derive inside a module where the implementation is genuinely the source of truth, such as store state or internal factory results.