The trick is the mapped-type-with-conditional pattern: build { [K in keyof T]: ... } where each value is K if the original type contains neither null nor undefined, and never otherwise. Indexing the result by [keyof T] collapses it into a union of just the surviving keys (the never entries are erased automatically). The -? removes optionality so an ?: field, which is implicitly T | undefined, is correctly classified as nullable. Use this whenever you need to derive a key list from an existing type rather than maintain it by hand.

Once you can extract the keys, Pick<T, NonNullableKeys<T>> projects a new type that retains only those entries. This is the right shape for an insert payload to a database (only the NOT NULL columns), a form's required-fields validator, or a query that has to fetch every non-nullable property. The runtime sentinel literal can omit nullable fields and still satisfy the static contract because nullable keys are no longer in the projected type. Pair this with a runtime stripper (next accordion) when you need value-level enforcement, not just a type guarantee.

Pairing the type with a runtime stripper closes the loop: callers pass a partially-populated object and get back a subset that matches the static RequiredFields<T> shape. The body is a plain key walk that drops null and undefined, which mirrors how most JSON-to-DB layers treat optional columns. The cast at the return is honest about the static-vs-runtime gap; the function trusts that the input fits T and returns the projected shape for callers downstream. Combine this with API request mappers, GraphQL resolvers, or any boundary that wants 'no nulls past this point'.