Missing TypeScript Terms — AI Knowledge Base (Gap Analysis)

Purpose: This document is an input for an AI generation pass. It lists the terms that are used in the existing 08-typescript/ prose but never defined as their own term, plus the terms a learner needs to reach "hero"/mastery that the curriculum never introduces, plus the relationships each missing term has to other missing terms and to existing terms. Every row is pre-shaped to drop directly into the curriculum's 8-section term template (Prerequisites → Category → Environment → Explanation → Common Mistakes → Exercises → Related Terms → Key Takeaways).

Scope reviewed: 58 existing term files across terms/level_01 … terms/level_10, plus _meta/typescript_terms_zero_to_hero.md and _meta/technology_context.md.

Method: (1) Diffed the index's declared filenames against disk — a perfect 1:1 match by filename (all 58 present, none orphaned). (2) Cross-checked each file's internal # Term #N number and > **Level X — …** header against the index and its directory — this surfaced a level-grouping inconsistency (Section 0). (3) grep-scanned the corpus for concepts that appear in prose/code but have no term file, filtering false positives (e.g. "inferred" vs the infer keyword) by matching real token usage. No broken links exist, so "missing" means conceptual gaps plus the grouping inconsistency, not dangling references.

---

0. Structural findings the generating AI must know first

Finding 1 — Term numbers are a clean spine, but the level grouping disagrees three ways.

Every term carries a correct, unique # Term #N (1–58) and every index filename exists on disk. Do not renumber the terms. However, for terms 31–45, the index, the directory folders, and the files' own > **Level X** headers group and title them inconsistently — and two directories even contain files with two different level titles:

So generics term #31 physically lives in level_08/, while advanced-type terms #41/#44/#45 live in level_10/ next to the modules terms — and level_08/ and level_10/ each mix two level titles. Minor drift also exists in Level 9: static_members.md says "Level 9 — Classes & OOP in TypeScript" while its five siblings say "Level 9 — Object-Oriented Programming (OOP)".

Recommended canonical grouping (adopt one scheme and make the index, dir names, and headers all agree). Because the term-number blocks 31–35 / 36–40 / 41–45 are already coherent, the cleanest fix is to treat them as three distinct levels — an 11-level curriculum:

Level 7  — Generics                                 (31–35)  → generics, multiple_generics,
                                                                generic_constraints,
                                                                generic_interfaces_classes,
                                                                default_generics
Level 8  — Utility Types                             (36–40)  → utility_types, partial_required,
                                                                pick_omit, record, returntype
Level 9  — Advanced Types                            (41–45)  → keyof, typeof, indexed_access,
                                                                conditional_types, mapped_types
Level 10 — Classes & OOP in TypeScript               (46–51)  → classes, access_modifiers,
                                                                implements, abstract_classes,
                                                                static_members, parameter_properties
Level 11 — Modules, Declaration Files & Configuration (52–58) → modules, namespaces,
                                                                declaration_files, definitely_typed,
                                                                enums, const_assertions, strict_mode

If the "10 levels" count must be preserved, instead merge Classes & OOP + Modules/Config into one final level — but either way, make one grouping authoritative and rewrite the mismatched directory names and > **Level X** headers to match it (and fix the static_members.md title). This is a labeling/foldering fix only; no term content or numbering changes.

Finding 2 — No missing_* deliverable or _meta/missing_terms.md tracker exists yet.

When these terms are generated, create _meta/missing_terms.md to record them, mirroring the 03-javascript/05-nodejs tracker convention.

---

1. Critical gaps — concepts used in existing prose but never defined

These block comprehension the most because existing terms depend on them in prose/code.

---

2. Missing terms by level

Each row: Proposed Term | description | Category | Prerequisites | Related. Categories follow technology_context.md (Types, Compiler, Architecture) refined into the ones the KB already implies — Type System Fundamental, Type Operator, Advanced Type, Utility Type, OOP, Compiler / Config, Module System. Environment must be Build-time, Runtime, or Both (the crucial TS distinction). 🆕 = used-but-undefined · ➕ = absent but needed for mastery. Level numbers below use the canonical 11-level grouping from Section 0.

Level 1 — Core Concepts (the foundational mental model that's mandated but missing)

Level 2 — Basic Types (null-safety, the core of strict mode)

Level 3 — Object Types & Interfaces (the interface-vs-type differentiators)

Level 5 — Union & Intersection Types (the assertion escape hatches)

Level 6 — Type Narrowing & Guards (complete the guard family)

Level 8 — Utility Types (fill out the standard library)

Level 9 — Advanced Types (the type-level programming engine)

Level 10 — Classes & OOP (the missing framework-critical feature)

Level 11 — Modules, Declaration Files & Configuration (build-graph reality)

---

3. Relationship map (dependency graph)

Notation: A → B means "A requires / builds on B". Bold = existing term; plain = missing.

Cluster 1 — The structural foundation (deepens Level 1, mandated by tech context)

**TypeScript** → Structural Typing / Duck Typing
Structural Typing → **Interfaces** / **implements** / **Generic Constraints**  (all explain via it)
Structural Typing → Branded / Nominal Types   (how to *escape* structural when you need nominal)
**Type Inference** → Type Widening → Const Assertions / satisfies

Cluster 2 — Null safety & assertions (Levels 2 & 5)

**Strict Mode** → null/undefined & strictNullChecks → Non-null Assertion (!)
null/undefined → **Type Narrowing** → Assertion Functions (asserts)
Type Widening → satisfies Operator → **Const Assertions**

Cluster 3 — Narrowing & guards completion (Level 6)

**Custom Type Guards** (is) → Assertion Functions (asserts)
**Discriminated Unions** + **never** → Exhaustiveness Checking → **Union Types**

Cluster 4 — Interfaces, merging & modules (Levels 3 & 11)

**Interfaces** → Declaration Merging → **Namespaces** (also merge)
**ES Modules** → Type-Only Imports (import type) → **Declaration Files**
**tsconfig.json** → Module Resolution & Path Aliases → **DefinitelyTyped**

Cluster 5 — The type-level programming engine (Levels 8–9)

**Conditional Types** → the infer Keyword → **ReturnType** / Awaited / Parameters
**Utility Types** → Exclude / Extract / NonNullable   (union filtering via Conditional Types)
**Literal Types** → Template Literal Types → Key Remapping in Mapped Types (as)
**Mapped Types** + **keyof** → Key Remapping in Mapped Types
Structural Typing → Branded / Nominal Types → **Intersection Types**

Cluster 6 — OOP metadata (Level 10)

**Classes** → Decorators → **Access Modifiers** / **Static Members**
Decorators → Declaration Files   (typing third-party decorators)

---

4. Suggested generation priority

---

5. Notes for the generating AI

1. Follow the existing 8-section template exactly (see terms/level_02/unknown.md, terms/level_10/conditional_types.md): Prerequisites → Term Category → Environment Context → Explanation (1. Design Motivation / 2. Core mechanics / 3. Real-world usage) → Common Mistakes & Pitfalls (with a "Golden Rule") → Practice Exercises (with a <details> hint block) → Related Terms → Key Takeaways. Use the > **Level X — [Name]** quote block under the H1.
2. Obey _meta/technology_context.md: Senior Full-Stack Architect persona; pragmatic, exact, structural. Champion Strict Mode and Type Inference; treat any as a code smell (steer to unknown/generics); stress the Type Aliases vs Interfaces distinction; and repeatedly frame TS as a Structural (Duck-Typed) system — which is exactly why the new "Structural Typing" term (P1) is so load-bearing.
3. Always mark the Build-time vs Runtime boundary in Section 3 — it's the crux of many of these terms (import type erases at build time; Decorators emit runtime code; type-level features like infer/mapped types vanish at runtime).
4. Unify the level grouping first (Section 0, Finding 1). Pick the canonical scheme, then make the _meta index, the directory names, and every file's > **Level X** header agree. Do not change any # Term #N number — the numbering is already correct and is the stable spine.
5. Use the KB's Category vocabulary — the tech context names Types, Compiler, Architecture; Section 2 refines these (Type System Fundamental, Type Operator, Advanced Type, Utility Type, OOP, Compiler / Config, Module System). Align each new term to the closest label already in use.
6. Wire cross-links using relative paths ../level_XX/<file>.md, matching the Prerequisites/Related columns in Section 2. Every new term must be reachable from at least one existing term (add it to that term's Related section too) — e.g. add infer to conditional_types.md and returntype.md, and Structural Typing to implements.md.
7. Renumber additions consistently. Existing terms run # Term #1…#58. Decide whether new terms append after #58 or slot into their level with a decimal/level-relative scheme, and apply it uniformly across the index and headers.
8. Create _meta/missing_terms.md (it does not exist here yet) and record each generated term, mirroring the tracker convention in the other knowledge bases.
9. Marker meaning: 🆕 = used-but-undefined in existing prose/code (highest priority — closes holes in what's already taught, e.g. infer, Structural Typing). ➕ = absent but needed for mastery (modern TS a "hero" must know: Template Literals, satisfies, Decorators). Generate in the Section 4 priority order.