NonNullable<T> / ReturnType<T> / Parameters<T>

NonNullable<T> // Remove null and undefined from T
ReturnType<T> // Return type of function type T
Parameters<T> // Parameter types of function type T (as a tuple)
Awaited<T> // Recursively resolved type of Promise<T>

type MaybeString = string | null | undefined;
type DefiniteString = NonNullable<MaybeString>;
// => string

// ReturnType
function greet(name: string): string {
  return `Hello, ${name}`;
}
type GreetReturn = ReturnType<typeof greet>;
// => string

function fetchUser() {
  return { id: 1, name: 'Ikari Shinji' };
}
type User = ReturnType<typeof fetchUser>;
// => { id: number; name: string }

// Parameters
function add(a: number, b: number): number {
  return a + b;
}
type AddParams = Parameters<typeof add>;
// => [a: number, b: number]

// Awaited
type Resolved = Awaited<Promise<string>>;
// => string

type DeepResolved = Awaited<Promise<Promise<number>>>;
// => number

These utility types are especially useful when working with external libraries where you cannot define types yourself. For example, using ReturnType<typeof someLibraryFn> lets you automatically capture the return type of a library function.

Since Parameters<T> returns a tuple type, you can use index access to extract individual parameter types — for example, Parameters<typeof fn>[0] gives you the type of the first parameter.

Awaited<T> is handy when you need the resolved value type of an async function. Because an async function's return type is automatically wrapped in a Promise, using ReturnType<typeof asyncFn> alone would give you the Promise type. Combining them as Awaited<ReturnType<typeof asyncFn>> unwraps it to the actual resolved value type.