[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","layouts/app-shell",{"_301":-5,"_9":10},"routes/subjects.$subject.topics.$topic",{"_9":10,"_11":12,"_13":14,"_15":16},"guest",true,"subjectTitle","Advanced TypeScript","topicTitle","Utility and Mapped Types","questions",[17,18,19,20,21,22,23,24,25,26,27,28,29,30,31],{"_32":283,"_34":284,"_36":285,"_38":39,"_40":286,"_42":287,"_44":288},{"_32":266,"_34":130,"_36":267,"_38":39,"_40":268,"_42":269,"_44":270},{"_32":249,"_34":35,"_36":250,"_38":39,"_40":251,"_42":252,"_44":253},{"_32":232,"_34":35,"_36":233,"_38":39,"_40":234,"_42":235,"_44":236},{"_32":215,"_34":35,"_36":216,"_38":39,"_40":217,"_42":218,"_44":219},{"_32":198,"_34":35,"_36":199,"_38":39,"_40":200,"_42":201,"_44":202},{"_32":181,"_34":35,"_36":182,"_38":39,"_40":183,"_42":184,"_44":185},{"_32":164,"_34":35,"_36":165,"_38":39,"_40":166,"_42":167,"_44":168},{"_32":147,"_34":35,"_36":148,"_38":39,"_40":149,"_42":150,"_44":151},{"_32":129,"_34":130,"_36":131,"_38":39,"_40":132,"_42":133,"_44":134},{"_32":112,"_34":35,"_36":113,"_38":39,"_40":114,"_42":115,"_44":116},{"_32":95,"_34":35,"_36":96,"_38":39,"_40":97,"_42":98,"_44":99},{"_32":78,"_34":35,"_36":79,"_38":39,"_40":80,"_42":81,"_44":82},{"_32":61,"_34":62,"_36":-5,"_38":-5,"_40":63,"_42":64,"_44":65},{"_32":33,"_34":35,"_36":37,"_38":39,"_40":41,"_42":43,"_44":45},"id","cmuo4z6rd037r20jxift05vmu","stem","What type does TypeScript work out for `x`?","codeBlock","type Env = \"dev\" | \"prod\";\n\ntype Key = `${Uppercase}_URL`;\n\ntype x = Record;","codeLang","ts","notes","## Template Literal Types and Built-in String Types\n\nA template literal type builds string types out of other types. When you give it a union, it makes every combination.\n\nFour built-in types change letter case: `Uppercase`, `Lowercase`, `Capitalize`, `Uncapitalize`. The compiler handles these itself.\n\nA template like `` `${Uppercase}_URL` `` applied to a union `Env = \"dev\" | \"prod\"` runs once per option, giving `\"DEV_URL\" | \"PROD_URL\"`. That list of exact string names can then be used as the keys for **`Record`** — `Record` builds an object type that needs exactly those keys, each holding a `string`.","explanation","A template literal type distributes over a union in its placeholder. `Uppercase<\"dev\" | \"prod\">` is `\"DEV\" | \"PROD\"`, so `Key` is `\"DEV_URL\" | \"PROD_URL\"`. `Record` then makes one required property per member.","options",[46,47,48,49],{"_32":59,"_51":60,"_36":-5,"_53":10},{"_32":57,"_51":58,"_36":-5,"_53":54},{"_32":55,"_51":56,"_36":-5,"_53":54},{"_32":50,"_51":52,"_36":-5,"_53":54},"cmuo4z6rj037v20jx3j96guce","text","`{ dev_URL: string; prod_URL: string }`","isCorrect",false,"cmuo4z6ri037u20jxeoul1ca8","`{ [key: string]: string }`, because a template key turns into a general string index","cmuo4z6rg037t20jx34ih7bbq","A single key made from the raw template text, because the template is never expanded","cmuo4z6rf037s20jxt5o0g6kk","`{ DEV_URL: string; PROD_URL: string }`","cmuo4z6r5037m20jx1v6eoidy","Which of these statements about `Pick` and `Omit` is true?","- **`Pick`** — keeps only the keys you list in `K`. The keys must be real keys of `T`.\n- **`Omit`** — drops the keys you list in `K`. These keys are *not* checked against `T`.\n\n**Watch out: `Omit` does not check that the key is real.** `Omit` (typo) compiles fine and gives back the whole type. `Pick` would show an error. So typos in `Omit` are silent.\n\n`Omit` is written as `Pick>`.\n\n**Watch out: `Pick` has the same union problem as `Omit`**, and so does anything built on `keyof T` when `T` might be a union. `Partial` and `Readonly` do split unions correctly, because they are homomorphic. `Omit` and `Pick` do not, because they work out the key list once, before the mapping starts.","The library declares `Pick` but `Omit`. So `Pick` is an error, while `Omit` compiles and quietly returns the full `User`. This is a common source of bugs after a property is renamed.",[66,67,68,69],{"_32":76,"_51":77,"_36":-5,"_53":54},{"_32":74,"_51":75,"_36":-5,"_53":54},{"_32":72,"_51":73,"_36":-5,"_53":10},{"_32":70,"_51":71,"_36":-5,"_53":54},"cmuo4z6rb037q20jx9hambpdz","Neither one checks key names. Both accept any string.","cmuo4z6ra037p20jxcyt4wpeg","`Pick` requires `K` to be a real key of `T`, so a misspelled key is an error. `Omit` accepts any string, number or symbol, so a misspelled key just removes nothing and there is no error.","cmuo4z6r8037o20jxyrj4tul6","Both `Pick` and `Omit` give an error for key names that are not on `T`.","cmuo4z6r6037n20jxwwpxelqj","`Omit` gives an error for unknown keys, while `Pick` accepts them and gives the missing field the type `unknown`.","cmuo4z6qx037h20jxbbj94jl4","type Raw = {\n a: string | null;\n b: number | undefined;\n};\n\ntype Clean = { [K in keyof T]: NonNullable };\n\ntype x = Clean;","### Types that change unions\n\n- **`NonNullable`** — drops `null` and `undefined`.\n\n```ts\ntype Sure = NonNullable; // string\n```\n\nUsed inside a mapped type, `NonNullable` can be applied to each property: `{ [K in keyof T]: NonNullable }` goes through every key of `T` and strips `null`/`undefined` from that one property's value, so `string | null` becomes `string` and `number | undefined` becomes `number`. The keys themselves don't change.","`NonNullable` removes both `null` and `undefined` from a union. Changing a property's type does not change its optional marker, and neither property here was declared with `?`, so both stay required.",[83,84,85,86],{"_32":93,"_51":94,"_36":-5,"_53":54},{"_32":91,"_51":92,"_36":-5,"_53":10},{"_32":89,"_51":90,"_36":-5,"_53":54},{"_32":87,"_51":88,"_36":-5,"_53":54},"cmuo4z6r3037l20jxioumlrs1","`{ a: never; b: never }`","cmuo4z6r2037k20jxvzsg8n1s","`{ a: string; b?: number }`. Removing `undefined` makes `b` optional.","cmuo4z6r0037j20jxonnr89gm","`{ a: string; b: number }`","cmuo4z6qz037i20jxp67uimpe","`{ a: string | null; b: number }`. `NonNullable` only removes `undefined`.","cmuo4z6qp037c20jx90g3tdox","type Nums = number[];\n\ntype MyPartial = { [K in keyof T]?: T[K] };\ntype NotHomomorphic = { [K in keyof T & string]?: T[K] };\n\ntype x = MyPartial;","## Homomorphic Mapped Types\n\nIf a mapped type has the exact shape `[K in keyof T]`, and `T` is a type parameter, it is called *homomorphic* — \"same shape in, same shape out\". It keeps the `readonly` and `?` marks, and it turns arrays into arrays and tuples into tuples instead of into plain objects.\n\n```ts\ntype Clone = { [K in keyof T]: T[K] }; // same shape kept\ntype NotClone = { [K in keyof T & string]: T[K] }; // shape lost\n\ntype A = Clone; // readonly string[]\ntype B = NotClone; // { [x: string]: string } - shape lost\n```\n\nSince `MyPartial = { [K in keyof T]?: T[K] }` has exactly this same-shape form, using it on an array type like `number[]` keeps the array shape instead of turning it into some indexed object — it stays an array.","A mapped type of the exact shape `[K in keyof T]` where `T` is a type parameter is homomorphic. Applied to an array or tuple, it produces an array or tuple rather than a plain object, and it preserves modifiers. `NotHomomorphic` uses `keyof T & string`, which breaks that special form and would give a plain object.",[100,101,102,103],{"_32":110,"_51":111,"_36":-5,"_53":10},{"_32":108,"_51":109,"_36":-5,"_53":54},{"_32":106,"_51":107,"_36":-5,"_53":54},{"_32":104,"_51":105,"_36":-5,"_53":54},"cmuo4z6qw037g20jxbjknmlzj","An object holding every array member made optional, including `length` and `push`.","cmuo4z6qu037f20jxdidvc156","`number[]` or `undefined`","cmuo4z6qt037e20jx1s8bceym","`never`, because you cannot use a mapped type on an array","cmuo4z6qr037d20jxvqscgoyg","`(number | undefined)[]`. The mapped type copies the shape of the array, so the result is still an array.","cmuo4z6qg037720jxyvpmsyay","type Config = {\n readonly host?: string;\n readonly port?: number;\n};\n\ntype Solid = {\n -readonly [K in keyof T]-?: T[K];\n};\n\ntype x = Solid;","## Modifiers: `+` and `-`\n\n```ts\ntype Mutable = {\n -readonly [K in keyof T]: T[K];\n};\n\ntype Concrete = {\n [K in keyof T]-?: T[K];\n};\n```\n\n`-readonly` takes the `readonly` mark off every key; `-?` takes the `?` off every key, so every property becomes required. Combine both (`-readonly [K in keyof T]-?`) and you get a type where every property is both changeable and required.\n\n**Watch out: `-?` also drops `undefined` from the value.** In `{ a?: string }` the value type is really `string | undefined`. After `-?` it is just `string`. That is usually what you want, but it does change the value type, not only the optional flag.","`-readonly` strips the read-only mark and `-?` strips the optional mark. Stripping `?` also removes `undefined` from each property type, so you get two required, writable properties.",[117,118,119,120],{"_32":127,"_51":128,"_36":-5,"_53":10},{"_32":125,"_51":126,"_36":-5,"_53":54},{"_32":123,"_51":124,"_36":-5,"_53":54},{"_32":121,"_51":122,"_36":-5,"_53":54},"cmuo4z6qn037b20jx6czfmpfc","`{ host?: string; port?: number }`. The `-?` only removes `undefined` from the type, not the optional marker.","cmuo4z6qm037a20jxevg6a1d4","`{ host: string | undefined; port: number | undefined }`","cmuo4z6qk037920jx4k9d4svm","`{ readonly host: string; readonly port: number }`","cmuo4z6qi037820jxj32lx623","`{ host: string; port: number }`","cmuo4z6q7037220jxl3tzvked","Which line does not compile, and what is the reason?","type Role = \"admin\" | \"editor\";\n\nconst perms: Record = {\n admin: [\"read\", \"write\"], // line A\n editor: [\"read\"], // line B\n};\n\nconst partial: Partial> = {\n admin: [\"read\"], // line C\n};\n\nconst missing: Record = {\n admin: [\"read\"], // line D\n};","- **`Record`** — builds an object type. `K` is the set of keys. `V` is the type of each value.\n\n```ts\ntype ByRole = Record<\"admin\" | \"guest\", User[]>;\n```\n\nWith `Record`, every key in the union `K` is required in the resulting object — you have to give a value for each one, or TypeScript flags an error. `Partial>` makes all of those keys optional instead, so it's fine to leave some of them out.","`Record` is a mapped type over `K` with no `?`, so every key is required. `Partial` wraps it and adds `?` to each key, which is why line C is fine and line D is not.",[135,136,137,138],{"_32":145,"_51":146,"_36":-5,"_53":54},{"_32":143,"_51":144,"_36":-5,"_53":54},{"_32":141,"_51":142,"_36":-5,"_53":54},{"_32":139,"_51":140,"_36":-5,"_53":10},"cmuo4z6qf037620jxcppvobva","Line D. `Record` needs every key from `Role`, so leaving out `editor` is an error.","cmuo4z6qd037520jx24hs4efb","Line C. You cannot use `Partial` on the result of `Record`.","cmuo4z6qb037420jxp3eaimjl","No line fails. `Record` keys are optional when the key type is a union of string literals.","cmuo4z6q9037320jxm0g1xweu","Lines C and D. `Record` keys are always required and `Partial` cannot change that.","cmuo4z6pz036x20jxqa0ylymv","type A = \"a\" | \"b\" | \"c\" | 1 | 2;\n\ntype x = Extract | Exclude;","### Types that change unions\n\n- **`Exclude`** — drops the options in `T` that fit `U`.\n- **`Extract`** — keeps only the options in `T` that fit `U`.\n\n```ts\ntype Status = \"idle\" | \"loading\" | \"error\" | \"done\";\n\ntype Settled = Exclude; // \"error\" | \"done\"\ntype Busy = Extract; // \"idle\" | \"loading\"\n```\n\nThese work one option at a time, walking through the union: `Extract` keeps only the matching options, `Exclude` keeps only the options that don't match.","`Extract` keeps the members assignable to `string`, giving `\"a\" | \"b\" | \"c\"`. `Exclude` removes those three plus `1`, leaving `2`. Joining them gives `\"a\" | \"b\" | \"c\" | 2`.",[152,153,154,155],{"_32":162,"_51":163,"_36":-5,"_53":54},{"_32":160,"_51":161,"_36":-5,"_53":10},{"_32":158,"_51":159,"_36":-5,"_53":54},{"_32":156,"_51":157,"_36":-5,"_53":54},"cmuo4z6q6037120jxk5g1um5d","`\"a\"`, `\"b\"`, `\"c\"` or `2`, but only when `Extract` is written first","cmuo4z6q4037020jx4l5fdupc","`\"a\"`, `\"b\"`, `\"c\"` or `2`","cmuo4z6q3036z20jx4dp1fnfz","`\"a\"`, `\"b\"`, `\"c\"` or `2`. `Extract` keeps the string members. `Exclude` throws away the strings and `1`, leaving `2`. The union of the two is the answer.","cmuo4z6q1036y20jxfw84po7v","`\"a\"`, `\"b\"`, `\"c\"`, `1` or `2`","cmuo4z6pr036s20jxiyatc39x","type Handler = (event: string, count: number, flag?: boolean) => void;\n\ntype x = Parameters;","### Types for functions and promises\n\n- **`Parameters`** — the function's arguments, as a tuple (a fixed-length list).\n\n```ts\nfunction createUser(name: string, age: number) {\n return { id: 1, name, age };\n}\n\ntype Args = Parameters; // [name: string, age: number]\n```\n\n`Parameters` pulls out a function type's parameter list as a tuple, keeping each parameter's name, type, and whether it's optional (an optional parameter like `flag?: boolean` shows up as an optional slot in the tuple).\n\n**Watch out: overloads get cut down.** If a function has several signatures, `Parameters` only sees the last one.","`Parameters` gives a tuple of the parameter types, keeping both the parameter names as labels and the optional marker. It is not a union and not an object.",[169,170,171,172],{"_32":179,"_51":180,"_36":-5,"_53":54},{"_32":177,"_51":178,"_36":-5,"_53":54},{"_32":175,"_51":176,"_36":-5,"_53":54},{"_32":173,"_51":174,"_36":-5,"_53":10},"cmuo4z6px036w20jxr6uqm8mt","A tuple: `[event: string, count: number, flag?: boolean]`","cmuo4z6pw036v20jxju9qhcrl","`string`, `number`, `boolean` or `undefined`","cmuo4z6pu036u20jxfzv5bkrh","`[string, number, boolean]`, with the optional marker removed","cmuo4z6pt036t20jxn1vj39vp","`{ event: string; count: number; flag?: boolean }`","cmuo4z6pj036n20jxskhms7c4","async function load(id: number) {\n return { id, ok: true };\n}\n\ntype x = Awaited>;","### Types for functions and promises\n\n- **`ReturnType`** — what the function gives back.\n- **`Awaited`** — what a promise ends up holding. It unwraps nested promises too.\n\n```ts\nfunction createUser(name: string, age: number) {\n return { id: 1, name, age };\n}\n\ntype NewUser = ReturnType; // { id: number; name: string; age: number }\n```\n\n**Watch out: you need `typeof` for real functions.** A function is a value, not a type, so you write `ReturnType`, not `ReturnType`. An `async function` always returns a `Promise<...>`, so `ReturnType` gives you back a `Promise`. Wrapping that with `Awaited<...>` unwraps the promise to get the value it resolves to, `X`.","`ReturnType` is `Promise<{ id: number; ok: boolean }>` because an `async` function always returns a promise. `Awaited` unwraps that promise. `ok: true` widens to `boolean` because the object literal property is mutable and not in a `const` context.",[186,187,188,189],{"_32":196,"_51":197,"_36":-5,"_53":54},{"_32":194,"_51":195,"_36":-5,"_53":10},{"_32":192,"_51":193,"_36":-5,"_53":54},{"_32":190,"_51":191,"_36":-5,"_53":54},"cmuo4z6pq036r20jxbr2s056t","`any`, because `ReturnType` cannot look inside an async function","cmuo4z6po036q20jxzts3j0qc","`{ id: number; ok: true }`","cmuo4z6pn036p20jxx6r1dv1i","`{ id: number; ok: boolean }`","cmuo4z6pl036o20jxdj6yk540","`Promise<{ id: number; ok: boolean }>`","cmuo4z6pb036i20jxy0uvy326","type Mixed = {\n id: number;\n name: string;\n run: () => void;\n save: (n: number) => boolean;\n};\n\ntype RemoveMethods = {\n [K in keyof T as T[K] extends Function ? never : K]: T[K];\n};\n\ndeclare const x: keyof RemoveMethods;","## Renaming Keys with `as`\n\nIf a key becomes `never`, it disappears from the result:\n\n```ts\ntype OnlyStrings = {\n [K in keyof T as T[K] extends string ? K : never]: T[K];\n};\n\ntype Picked = OnlyStrings<{ id: number; name: string }>; // { name: string }\n```\n\nThe `as` clause can check each key's value type and decide whether to keep that key or map it to `never`. Any key that becomes `never` is dropped completely from the result — that's how you filter out properties by what type they hold, like removing all the function properties.","When the `as` clause maps a key to `never`, that property is dropped from the result. `run` and `save` are functions, so they map to `never` and disappear. `id` and `name` keep their own keys.",[203,204,205,206],{"_32":213,"_51":214,"_36":-5,"_53":54},{"_32":211,"_51":212,"_36":-5,"_53":10},{"_32":209,"_51":210,"_36":-5,"_53":54},{"_32":207,"_51":208,"_36":-5,"_53":54},"cmuo4z6pi036m20jxda2vc8lq","`never`, because one side of the check gives back `never`","cmuo4z6pg036l20jx4eks4ks8","`\"id\"`, `\"name\"`, `\"run\"` or `\"save\"`, where `run` and `save` have the type `never`","cmuo4z6pe036k20jxtnlss4t8","`\"id\"` or `\"name\"`","cmuo4z6pd036j20jxy04k4mg5","`\"run\"` or `\"save\"`","cmuo4z6p1036d20jx8nyd1jnz","type Person = { name: string; age: number };\n\ntype Getters = {\n [K in keyof T as `get${Capitalize}`]: () => T[K];\n};\n\ntype G = Getters;\n\ndeclare const x: keyof G;","## Renaming Keys with `as`\n\nThe `as` clause lets you change each key's name. Pair it with template literal types to rename. Map a key to `never` to drop it.\n\n```ts\ntype Getters = {\n [K in keyof T as `get${Capitalize}`]: () => T[K];\n};\n\ntype UserGetters = Getters<{ name: string; age: number }>;\n// { getName: () => string; getAge: () => number }\n```\n\nEach key gets rewritten into a new name built with a template literal, so `name` becomes `getName` and `age` becomes `getAge`. The `string & K` part is there because keys could in theory be symbols or numbers, and the string-casing helpers need an actual string.","The `as` clause remaps each key. `Capitalize<\"name\">` is `\"Name\"`, and the template makes `\"getName\"`. The `string & K` part narrows `K` to its string part so `Capitalize` accepts it. The result keys are the literal types `\"getName\"` and `\"getAge\"`.",[220,221,222,223],{"_32":230,"_51":231,"_36":-5,"_53":54},{"_32":228,"_51":229,"_36":-5,"_53":54},{"_32":226,"_51":227,"_36":-5,"_53":10},{"_32":224,"_51":225,"_36":-5,"_53":54},"cmuo4z6p9036h20jx3x5saura","`\"getname\"` or `\"getage\"`","cmuo4z6p7036g20jx3c1ztsgm","`\"getName\"` or `\"getAge\"`","cmuo4z6p5036f20jx9tf8mevo","`\"name\"` or `\"age\"`","cmuo4z6p3036e20jxqzyo3y0h","`string`, because a template key makes the key type widen to plain `string`","cmuo4z6oq036820jx8nvs97p6","type User = {\n readonly id: number;\n name?: string;\n};\n\ntype Mutable = {\n -readonly [K in keyof T]: T[K];\n};\n\ntype M = Mutable;\n\ndeclare const x: M;","## Modifiers: `+` and `-`\n\nInside a mapped type you can add or remove `readonly` and `?`. Writing them plain means add. Writing `-` in front means remove.\n\n```ts\ntype Mutable = {\n -readonly [K in keyof T]: T[K];\n};\n```\n\n`-readonly` takes the `readonly` mark off every key, so a property written as `readonly id: number` becomes a normal, assignable `id: number`. It only affects `readonly` — if a property has a `?` (like `name?: string`), that `?` stays put. There is no built-in type for `-readonly`, so you have to write it yourself, like above.","This mapped type is homomorphic: it maps over `keyof T` where `T` is a type parameter, so it copies each property's modifiers by default. `-readonly` removes the read-only mark. Nothing touches `?`, so `name` stays optional.",[237,238,239,240],{"_32":247,"_51":248,"_36":-5,"_53":10},{"_32":245,"_51":246,"_36":-5,"_53":54},{"_32":243,"_51":244,"_36":-5,"_53":54},{"_32":241,"_51":242,"_36":-5,"_53":54},"cmuo4z6oz036c20jxd484qkrv","`{ id: number; name: string | undefined }`. Both the read-only mark and the optional mark are removed.","cmuo4z6ox036b20jxez0xpid5","`{ id: number; name?: string | undefined }` where `name` is still read-only, because `-readonly` only works when `-?` is written too.","cmuo4z6ov036a20jxitp5s21i","`{ readonly id: number; name?: string }`. The `-readonly` only affects new fields the mapped type adds.","cmuo4z6os036920jxi464a6kc","`{ id: number; name?: string }`. The read-only mark is removed, but the optional mark stays.","cmuo4z6oi036320jxl9jb3hfn","type Shape =\n | { kind: \"circle\"; radius: number }\n | { kind: \"square\"; size: number };\n\ntype NoKind = Omit;\n\ndeclare const x: NoKind;","## `Omit` Does Not Split Unions\n\n`Omit` is written as `Pick>`. It asks for `keyof T` once, for the whole union. And `keyof` on a union only gives the keys they all share. So omitting from a union flattens it into a single object holding only the shared keys.\n\n```ts\ntype Shape =\n | { kind: \"circle\"; radius: number }\n | { kind: \"square\"; side: number };\n\ntype NoKind = Omit;\n// { } - radius and side are both gone; the union is destroyed\n```\n\n**Watch out: nothing tells you it went wrong.** `Omit` shows no error. It just gives you a type with nothing useful in it, and every later check on the union stops working.","`Omit` is written as `Pick>`. `keyof Shape` on a union is the intersection of the members' keys, which here is just `\"kind\"`. Excluding `\"kind\"` leaves nothing, so the result is `{}`. To get the per-member result you need a distributive helper like `type DistOmit = T extends unknown ? Omit : never`.",[254,255,256,257],{"_32":264,"_51":265,"_36":-5,"_53":10},{"_32":262,"_51":263,"_36":-5,"_53":54},{"_32":260,"_51":261,"_36":-5,"_53":54},{"_32":258,"_51":259,"_36":-5,"_53":54},"cmuo4z6oo036720jxk87iayp4","`never`, because the two members share no keys other than `kind`","cmuo4z6on036620jx9119mtkz","`{ radius: number; size: number }`","cmuo4z6ol036520jx1qaf3gjg","`{ radius: number }` or `{ size: number }`","cmuo4z6oj036420jxal87yhkc","`{}`. `Omit` does not split the union apart. It keeps only keys shared by both members, and `kind` was the only shared key, so nothing is left.","cmuo4z6o9035y20jxvfqp4em7","type Point = { x: number; y: number };\n\nconst p: Readonly = { x: 1, y: 2 };\n\np.x = 5; // line A\nconst q = { ...p }; // line B\nq.x = 5; // line C\nconsole.log(p.y); // line D","**`Readonly`** — every property becomes read-only, so you cannot assign to it.\n\n```ts\ninterface User {\n id: number;\n name: string;\n email?: string;\n}\n\ntype Frozen = Readonly; // readonly id, name, email\n```\n\nOnce something has type `Readonly`, trying to assign to one of its properties (like `p.x = 5`) is an error, because every key got the `readonly` mark. But if you spread it into a brand new object (`{ ...p }`), TypeScript infers a normal, non-readonly type for that new object, so you can assign to its properties again. Just reading a readonly property is always fine.","`Readonly` adds `readonly` to each property, so writing `p.x` fails. Reading is always fine. A spread copies values into a fresh object literal whose inferred type has no `readonly`, so `q.x = 5` is allowed.",[271,272,273,274],{"_32":281,"_51":282,"_36":-5,"_53":54},{"_32":279,"_51":280,"_36":-5,"_53":54},{"_32":277,"_51":278,"_36":-5,"_53":10},{"_32":275,"_51":276,"_36":-5,"_53":54},"cmuo4z6og036220jx0fku5c70","Line B. You cannot spread a read-only object into a new object.","cmuo4z6oe036120jxr7o8rf92","Line A. `Readonly` makes every field read-only, so setting `p.x` is an error.","cmuo4z6od036020jxjesbwddj","Lines A and C. The spread on line B keeps the read-only marks on `q`.","cmuo4z6ob035z20jxtdvahl78","Line D. Reading a read-only field needs a type assertion.","cmuo4z6ny035t20jxlgcyvnpj","Look at the code below. What type does TypeScript work out for `x`?","type User = {\n id: number;\n name?: string;\n};\n\ntype R = Required;\n\ndeclare const x: R[\"name\"];","**`Required`** — every property becomes required. It takes the `?` off.\n\n```ts\ninterface User {\n id: number;\n name: string;\n email?: string;\n}\n\ntype Complete = Required; // email: string (not optional)\n```\n\n`Required` goes through every property of `T` and removes the `?`. So an optional property like `name?: string` turns into `name: string` — it is no longer allowed to be `undefined`.","`Required` removes the `?` from every property with `-?`. Removing `?` also strips `undefined` from the property type. So `name?: string` becomes `name: string`.",[289,290,291,292],{"_32":299,"_51":300,"_36":-5,"_53":10},{"_32":297,"_51":298,"_36":-5,"_53":54},{"_32":295,"_51":296,"_36":-5,"_53":54},{"_32":293,"_51":294,"_36":-5,"_53":54},"cmuo4z6o7035x20jx2dnq1r3o","`string` or `null`","cmuo4z6o5035w20jxmtfuojon","`never`, because `name` was optional and `Required` cannot fill it in","cmuo4z6o3035v20jxxzct88lw","`string` or `undefined`","cmuo4z6o1035u20jxi4ldl7wr","`string`","email"]