Ninety courses. Six benches.

Annotations, inference, and the first time the compiler is right and you are not. You finish comfortable leaving a file stricter than you found it.

• Add types to a small module without any
• Read a compiler error back to the real mismatch
• Let inference work where an annotation adds nothing

Unions, discriminants, and the checks that narrow them. You will stop using a cast to tell the compiler to trust you.

• Model a value as a union instead of optional fields
• Narrow a union with a check the compiler believes
• Remove a cast that was hiding a real case

Before this: Your First Typed File

Required, optional, and the union of variants. You will look at a props type and see the product decisions inside it.

• Design props that reject an illegal combination
• Choose a variant union over a pile of booleans
• Name a callback's arguments so the caller cannot drift

Before this: Unions and Narrowing

A beginner-length course on a single idea. The state object stops being a bag of flags that can all be true at once.

• Model loading, empty, ready, and failed as a union
• Render each state without checking three booleans
• Make the impossible combination a type error

Before this: Unions and Narrowing

Constraints, defaults, and inference sites, taught by removing duplication. Equal time goes to the overload that would have been clearer.

• Write a generic helper another person can call
• Add a constraint when the body needs one
• Prefer an overload when a generic is harder to read

Before this: Props as a Data Model

Menus, toasts, and form steps, each modeled so the render function is a switch the compiler can exhaust.

• Model a component as an exhaustive switch
• Add a variant without leaving a silent fall-through
• Keep the discriminant next to the data it describes

Before this: Types for Component State

Advanced. JSON, query strings, and form payloads arrive untyped no matter what your interfaces say. You will validate them and type the result, not the wish.

• Accept external data as unknown
• Parse it into a type the UI can trust
• Show a failure when the payload is not the shape you hoped

Before this: Unions and Narrowing

You will derive a type instead of copying it, and you will notice when the utility made the API harder to read.

• Derive a props variant with a utility type
• Read a mapped type and say what it produces
• Inline a utility when the name is hiding the shape

Before this: Generics You Can Read

ComponentType, props of a child, and a context value that cannot be undefined by accident.

• Type a context value so missing provider is a bug
• Describe children more tightly than ReactNode when you can
• Pass a component as a prop without losing its props

Before this: Props as a Data Model

Advanced. ExpectType-style checks and assertion functions. You will catch a type that got wider before a user catches the bug.

• Write a type-level assertion that fails the build
• Use a predicate to narrow, not a cast
• Notice when a public type got wider

Before this: Typing the Boundary

You will stop maintaining a type, a validator, and a default object as three drifting copies of the same form.

• Derive the value type from one schema
• Type field errors so a missing key is a compile error
• Submit a payload that matches the schema

Before this: Typing the Boundary

The React types people silence. You will type a change handler, a ref to a DOM node, and a list component that keeps the item type.

• Type an event handler without any
• Type a ref to the node you actually have
• Write a generic list that preserves the item type

Before this: Props as a Data Model

Public types, path exports, and a barrel file that accidentally became your API. You will draw a line and keep it.

• Mark a type as public or internal on purpose
• Stop a barrel file from widening your API
• Change an internal type without a downstream break

Before this: Utility Types in Anger

A button, a field, and a stack, with variant names that exist in exactly one place. Twelve weeks of making the system harder to misuse.

• Type a variant so a typo will not compile
• Share a token type between CSS and props
• Add a component without inventing a second naming scheme

Before this: React Types Without any

You bring a real file, or we give you one. The capstone is the diff: fewer casts, a parsed boundary, and a state union the render trusts.

• Replace a bag of flags with a state union
• Parse data at the boundary instead of casting it
• Leave a module another person can extend without any

Before this: Typing the Boundary