AboutTeamsPricing
New content added weeklyLive

Master Typescript with Adaptive AI.

Master Typescript across 30 topics - Foundations, Type System Mastery, and Advanced Type Engineering - guided by Leyaa's adaptive intelligence.

3Parts
30Topics
236Patterns
60hEst. duration
Start Learning Free
Typescript
Typescript Course
3 - part learning journey
Beginner
Foundations
12 topics · 88 patterns
Beginner
Intermediate
Type System Mastery
9 topics · 73 patterns
Intermediate
Advanced
Advanced Type Engineering
9 topics · 75 patterns
Advanced
Begin Part 1: Foundations
✦ Course Structure

Your Typescript Journey in 3 Parts

Each part builds on the last - a deliberate progression from beginner to advanced.

Beginner
Beginner
Part 1: Foundations
Covers TypeScript Basics and Compilation, Type Annotations and Inference, Primitive Types and 9 more topics.
12Topics
88Patterns
View topics
Intermediate
Intermediate
Part 2: Type System Mastery
Covers Generics Fundamentals, Generic Interfaces and Classes, Type Guards and Narrowing and 6 more topics.
9Topics
73Patterns
View topics
Advanced
Advanced
Part 3: Advanced Type Engineering
Covers Conditional Types, Mapped Types, Utility Types Part 2 and 6 more topics.
9Topics
75Patterns
View topics
Curriculum

Everything You'll Learn

Explore every topic and pattern in the course.

Typescript

3 parts · 30 topics · 236 patterns
Beginner
Part 1: Foundations12 topics · 88 patterns
Beginner
01
TypeScript Basics and Compilation
7 patterns
What is TypeScript
Why TypeScript over JavaScript
How TypeScript compiles to JavaScript
TypeScript Compiler Installation and Setup
tsconfig.json Configuration Basics
Running TypeScript with ts-node
TypeScript Strict Mode and Why It Matters
02
Type Annotations and Inference
8 patterns
Why type annotations are needed
Explicit type annotations
How TypeScript infers types automatically
Type annotation on variables
Type annotation on function parameters
Type annotation on return values
The any type and why to avoid it
Unknown type vs any type
03
Primitive Types
8 patterns
Number type behavior
String type behavior
Boolean type behavior
Null and undefined types
Strict null checks and safety
Void type for functions
Never type and unreachable code
Literal types and value narrowing
04
Arrays and Tuples
8 patterns
Why typed arrays matter
Array type annotation syntax
Generic array syntax
Read-only arrays
Tuple type definition
Tuple with fixed length and types
Optional elements in tuples
Rest elements in tuples
05
Object Types
7 patterns
Why object types are needed
Object type annotation inline
Optional properties
Readonly properties
Index signatures for dynamic keys
Excess property checking behavior
Nested object types
06
Union and Intersection Types
7 patterns
Why union types are needed
Union type syntax and behavior
Type narrowing with typeof
Discriminated unions
Intersection type syntax
How intersection combines types
Union vs intersection mental model
07
Type Aliases
6 patterns
Why type aliases are needed
Creating type aliases
Type alias for objects
Type alias for unions
Type alias for functions
Type alias vs inline types
08
Interfaces
8 patterns
Why interfaces are needed
Interface declaration syntax
Optional properties in interfaces
Readonly properties in interfaces
Extending interfaces
Multiple interface extension
Interface vs type alias decision
Implementing interfaces in classes
09
Structural Typing and Type Compatibility
6 patterns
What structural typing means
Duck typing mental model in TypeScript
How assignment compatibility is checked
Excess property checks vs structural compatibility
How structural typing differs from nominal typing
Fresh object literals vs variable assignment behavior
10
Compile-Time vs Runtime Boundary
6 patterns
Why understanding the boundary matters
What types exist only at compile time
What survives compilation to JavaScript
Why instanceof fails on interfaces
Type erasure and its consequences
Runtime type checking strategies
11
Functions in TypeScript
8 patterns
Why typed functions matter
Parameter type annotations
Return type annotations
Optional parameters
Default parameters with types
Rest parameters with types
Function overloads
Callback function types
12
Enums
9 patterns
Why enums are needed
Numeric enums
String enums
Heterogeneous enums
Enum member access
Reverse mapping in numeric enums
Const enums and optimization
When enums add unnecessary runtime code
Enum vs union literal type trade-offs
Intermediate
Part 2: Type System Mastery9 topics · 73 patterns
Intermediate
01
Generics Fundamentals
8 patterns
Why generics are needed
Generic function syntax
How TypeScript infers generic types
Generic constraints with extends
Multiple generic parameters
Default generic types
Generic functions with arrays
Generic arrow functions
02
Generic Interfaces and Classes
7 patterns
Why generic interfaces matter
Generic interface declaration
Generic class syntax
Generic class with constraints
Generic interface for collections
Generic factory pattern
Generic repository pattern
03
Type Guards and Narrowing
9 patterns
Why type narrowing is needed
typeof type guards
instanceof type guards
Truthiness narrowing
Equality narrowing
The in operator narrowing
Custom type guard functions
Discriminated union narrowing
Assertion functions
04
Advanced Type Operations
8 patterns
Why advanced types are needed
Keyof operator
Typeof operator in type context
Indexed access types
Template literal types
Type assertions
Non-null assertion operator
Satisfies operator
05
Classes in TypeScript
10 patterns
Why typed classes matter
Class property declarations
Constructor parameter types
Access modifiers public private protected
Readonly class properties
Parameter properties shorthand
Getter and setter with types
Static members with types
Abstract classes
Abstract methods
06
Class Inheritance and Polymorphism
7 patterns
Why inheritance needs types
Extending classes with types
Method overriding with types
Super keyword behavior
Polymorphism through interfaces
Class implementing multiple interfaces
Type compatibility with classes
07
Modules and Namespaces
9 patterns
Why modules are needed in TypeScript
Export syntax variations
Import syntax variations
Default exports vs named exports
Re-exporting modules
Type-only imports and exports
Dynamic imports with types
Namespace declaration
Namespace merging
08
Type Narrowing Patterns
7 patterns
Why patterns matter for safety
Optional chaining with types
Nullish coalescing with types
Type predicates in practice
Exhaustive checking with never
Control flow analysis behavior
Assertion signatures
09
Utility Types Part 1
8 patterns
Why utility types are needed
Partial type
Required type
Readonly utility type
Pick type
Omit type
Record type
Combining utility types
Advanced
Part 3: Advanced Type Engineering9 topics · 75 patterns
Advanced
01
Conditional Types
8 patterns
Why conditional types are needed
Conditional type syntax
Conditional type with generics
Inferring types with infer keyword
Distributive conditional types
Non-distributive conditional types
Nested conditional types
Conditional types for overload replacement
02
Mapped Types
8 patterns
Why mapped types are needed
Basic mapped type syntax
Mapped type modifiers (readonly, optional)
Removing modifiers with minus
Key remapping with as clause
Mapped type with template literals
Mapped type with conditional types
Mapped type for deep transformations
03
Utility Types Part 2
9 patterns
Why advanced utility types matter
Extract type
Exclude type
NonNullable type
ReturnType type
Parameters type
ConstructorParameters type
InstanceType type
ThisParameterType and OmitThisParameter
04
Template Literal Types
7 patterns
Why template literal types are powerful
Template literal type syntax
String manipulation types (Uppercase, Lowercase)
Capitalize and Uncapitalize types
Pattern matching with template literals
Template literal with unions
Building type-safe string patterns
05
Declaration Files
9 patterns
Why declaration files are needed
Declaration file syntax (.d.ts)
Declaring modules
Declaring global variables
Declaring functions and classes
Ambient declarations
DefinitelyTyped and @types packages
Writing custom declaration files
Triple-slash directives
06
Decorators
9 patterns
Why decorators are needed
Enabling decorators in TypeScript
Class decorators
Method decorators
Property decorators
Parameter decorators
Decorator factories
Decorator composition and execution order
Metadata reflection with decorators
07
Advanced Generics
8 patterns
Why advanced generics matter
Recursive generic types
Generic type variance
Covariance and contravariance
Generic conditional constraints
Higher-order function types
Builder pattern with generics
Type-safe event emitter pattern
08
Module Augmentation and Merging
7 patterns
Why module augmentation is needed
Declaration merging for interfaces
Declaration merging for namespaces
Module augmentation syntax
Global augmentation
Merging classes with interfaces
Augmenting third-party libraries
09
Advanced Patterns and Best Practices
10 patterns
Why type design patterns matter
Branded types for safety
Phantom types
Type-safe builder pattern
Discriminated union state machines
Exhaustive pattern matching
Type-safe API response handling
Strict configuration objects
Migrating JavaScript to TypeScript
TypeScript compiler API basics
Why Leyaa

Not just a course. A learning intelligence.

Leyaa doesn't just deliver content - it understands where you are, what you need, and how to get you there fastest.

Adaptive Diagnostics
Adaptive Diagnostics
Leyaa identifies which of the 236 patterns you've mastered and which need work - before you waste time on what you already know.
Pattern-Level Precision
Pattern-Level Precision
Every pattern gets a verdict - Learn, Practice, or Skip - so your study time goes exactly where it counts.
Intelligent Pacing
Intelligent Pacing
Leyaa reads your velocity across the whole course and adapts your focus list dynamically, keeping you in the optimal learning zone.
Before & After Visibility
Before & After Visibility
Every assessment creates a snapshot. Retake anytime to see exactly how much you've grown - topic by topic, pattern by pattern.
Learner Autonomy
Learner Autonomy
Leyaa recommends, never restricts. Override any suggestion and explore at your own pace - the system tracks everything regardless.
Clear Learning Path
Clear Learning Path
Foundations → Type System Mastery → Advanced Type Engineering - a structured journey where each part sets you up perfectly for the next.
Typescript

Ready to master Typescript?
Start your journey today

Start your diagnostic now. Build mastery across all 30 topics in under 15 minutes.

30 Topics
236 Patterns
Personalized roadmap
Leyaa Swift Bird