In a TypeScript mapped type, what does the `as` clause in `{ [K in keyof T as NewKey]: T[K] }` do, and what happens to a key whose `as` clause evaluates to `never`?

## The shape being described A mapped type builds an object type by iterating a union of keys: `{ [K in Keys]: ValueType }`. When `Keys` is `keyof T`, you are saying "one property for every property of `T`". By default the emitted property keeps the key it was iterated with. The `as` clause is an optional extra step in the *key position* that overrides that name: ```ts type Renamed = { [K in keyof T as NewKeyExpression]: ValueExpression }; ``` For every `K` in the union the compiler evaluates `NewKeyExpression` and emits the property under that computed name. Nothing else about the mapped type changes. One naming trap first: this `as` is unrelated to the `as` *type assertion* (`json as User`). They share a keyword and nothing else. The assertion tells the checker to stop arguing about an expression; the mapped-type clause computes a key. Neither one does anything at runtime, but they are different features. ## Renaming The clause is an ordinary type expression, so anything that produces a key type works — including a lookup into another type: ```ts type Wire = { user_id: number; created_at: string }; type Names = { user_id: "userId"; created_at: "createdAt" }; type Domain = { [K in keyof Wire as Names[K]]: Wire[K] }; // { userId: number; createdAt: string } ``` The computed result must be assignable to `string | number | symbol` (the built-in alias `PropertyKey`). Produce something that is not a key type and the compiler reports exactly that. ## `never` deletes the property `never` is the empty type — there is no key to emit — so the property does not appear in the result at all. This is the single most-asked fact about key remapping: ```ts type Data = { id: number; name: string; save(): void }; type Fields = { [K in keyof Data as Data[K] extends Function ? never : K]: Data[K]; }; // keyof Fields is "id" | "name" ``` The result is **not** `{ save: never }`. That is what you get if you put the conditional in the *value* position instead — the key survives with an uninhabitable type, which is worse than useless because the property still shows up in `keyof`, in destructuring, and in excess-property messages. Key position removes; value position replaces. ## `K` always means the original key Inside both the `as` clause and the value expression, `K` is bound to the key being iterated, never to the renamed one. That is why filtering by *value* type works: the clause can inspect `T[K]` while deciding what to call — or whether to emit — the property. The new name is write-only; nothing downstream in the same mapped type can read it. ## The Omit-shaped helper Before key remapping existed, subtracting keys was expressed by building the surviving key union first and then `Pick`ing with it — which is how the built-in `Omit<T, K>` is defined, as `Pick<T, Exclude<keyof T, K>>`. With remapping you can write it in one pass: ```ts type Without<T, K extends PropertyKey> = { [P in keyof T as P extends K ? never : P]: T[P]; }; type NoId = Without<{ id: number; label: string }, "id">; // { label: string } ``` Both forms are legitimate; the remapping form reads better when the predicate is about the *property*, not just the name, because `T[P]` is in scope. ## Two practical cautions First, `keyof T` is `string | number | symbol` in the general case. Any operation that only accepts string keys needs the key narrowed with `K & string`, otherwise the clause is a type error on the symbol member. Second, remember what tier you are working on. A key-remapped type is a *description*: the compiler emits no code for it, so nothing in the running program is renamed, filtered, or checked. A type that says a payload has `userId` does not make the parsed JSON have `userId` — only a mapping function does that. Key remapping is excellent at stating the contract that such a function must satisfy, and useless as a substitute for it.