PROWIDIT Education Academy

Blog
About us
How it works
FAQ

+994 77 333 38 36 Trial lesson Account

AZ RU EN

← Back to account

Switch courseTypeScript course

AI for developers course104
Algorithms and data structures course129
Django & FastAPI course140
Docker & deployment course103
Full Stack Developer course270
Git & GitHub course103
HTML & CSS course154
JavaScript course169
Laravel course136
Provider Networks: MPLS, BGP and BNG81
Next.js course113
Node.js course123
PHP course144
Python course153
React course122
SQL & databases course122
TypeScript course112
Vue.js course111

Getting Started with TypeScript
Why TypeScript: Static Typing on Top of JavaScript Free
Installing TypeScript and Running the tsc Compiler
Running TS Without a Build Step: tsx and Node.js 22 Type Stripping
tsconfig.json: Structure and Core Options
Strict Mode and Additional Compiler Checks
Working in the Editor: Reading Compiler Errors and Hints
Basic Types
Primitive Types: string, number, boolean, bigint, symbol
Type Annotations: Variables, Parameters and Return Values
Type Inference: let vs const, Widening and Contextual Typing
null and undefined: strictNullChecks, ?., ?? and the ! Operator
Arrays: T[], Array<T> and Inference in Array Methods
Tuples: Fixed Length, Named and Optional Elements
Object Types and Optional Properties
Type Aliases: Naming and Reusing Types
readonly: Immutable Properties, Arrays and Tuples
Index Signatures: Objects with Dynamic Keys
any, unknown and never: TypeScript's Special Types
Practice: A Typed Grade Book Module
Unions, Literal Types and Narrowing
Union Types: A Value of One of Several Types
Literal Types and as const
Narrowing with typeof, Truthiness and Equality
Narrowing with in and instanceof
Discriminated Unions: Using a Shared Tag Field
Exhaustiveness Checking with never
Type Assertions with as: When They Are Safe and When Not
Custom Type Guards: value is T Predicates
Assertion Functions: asserts value is T
Practice: An Order State Machine with Discriminated Unions
Modeling Data: Interfaces, Types and Enums
Interfaces: Describing the Shape of an Object
Extending Interfaces and Intersection Types
Interface Declaration Merging
type vs interface: Practical Rules for Choosing
Structural Typing and Type Compatibility
The typeof and keyof Type Operators
Indexed Access Types: T['key'] and T[number]
Enums: Numeric, String and const enum
as const Objects as an Enum Alternative
The satisfies Operator: Type Checking Without Widening
Typing Functions
Function Types: Type Expressions and Call Signatures
Function Parameters: Optional, Default, Rest and Destructured
Return Types: Explicit Annotations, void, undefined and never
Callbacks and Function Compatibility
Function Overloads
Typing this in Functions and Methods
TypeScript in the Browser: DOM and Events
A Frontend Project with Vite and TypeScript
Typing DOM Elements: querySelector and the HTMLElement Hierarchy
Typing Events: Event, MouseEvent, KeyboardEvent
Forms and Inputs: value, FormData and Validation
localStorage and JSON: Reading Data Safely
Project: A Typed To-Do App
Generics
Why Generics: From any to Type Parameters
Generic Functions: Type Argument Inference and Multiple Parameters
Generic Constraints: extends and K extends keyof T
Generic Types and Interfaces with Default Type Parameters
Controlling Inference: const Type Parameters and NoInfer
Generic Higher-Order Functions and Variadic Tuples
Practice: A Typed EventEmitter
Utility Types and Type Transformations
Utility Types: Partial, Required and Readonly
Pick, Omit and Record: Selecting Keys and Building Dictionaries
Exclude, Extract and NonNullable: Working with Unions
ReturnType, Parameters, Awaited and Other Function Utilities
Mapped Types: [K in keyof T]
Modifiers and Key Remapping in Mapped Types
Conditional Types: T extends U ? X : Y
Distributive Conditional Types
The infer Keyword: Extracting Types
Template Literal Types and Intrinsic String Types
Recursive Types: Trees, JSON and DeepPartial
Branded Types: Nominal Typing in TypeScript
Project: Generic Data Table Utilities
Classes, OOP and Decorators
Classes in TypeScript: Fields, Constructors and Parameter Properties
Access Modifiers: public, private, protected and #private
Class Inheritance and the override Keyword
Abstract Classes and Implementing Interfaces
Static Members and the Polymorphic this Type
Generic Classes: Collections and Repositories
Decorators (TC39 Standard): Methods and Classes
Field and Accessor Decorators, Metadata
Resource Management: using, Disposable and AsyncDisposable
Async Code, Errors, APIs and Zod
Typing Promises and async/await
Error Handling: catch (e: unknown) and Custom Error Classes
The Result Pattern: Errors as Values
Typing fetch: Requests and Responses
Modeling API Responses: DTOs, Pagination and Generated Types
Zod: Schemas, parse/safeParse and z.infer
Zod: Composing Schemas, Unions and Arrays
Zod: Transforms, Refinements and Coercion
Project: A Typed API Client
Modules and Declaration Files
ES Modules in TypeScript: import type and verbatimModuleSyntax
Module Resolution: module, moduleResolution and Path Aliases
Declaration Files (.d.ts): What's Inside and How to Generate Them
Third-Party Library Types: @types and DefinitelyTyped
declare: Ambient Declarations and Module Augmentation
Practice: Writing a .d.ts for an Untyped JS Library
TypeScript on the Server: Node.js and Express
A Node.js 22 Project with TypeScript: Setup and Build
Typed Configuration: Environment Variables and Zod
Express 5 with TypeScript: Typing Request and Response
Express: Request Validation with Zod and Typed Middleware
Express: Centralized Error Handling and Layered Architecture
Project: A REST API with Express and TypeScript
TypeScript with React
React with TypeScript: Vite Setup and Typing Props
Typing Hooks: useState, useReducer, useRef and useContext
Events and Forms in React with TypeScript
Generic Components and Custom Hooks
Practice: A Product Catalog with React and TypeScript
Code Quality, Testing, Migration and Final Project
TypeScript Project Structure and Project References
ESLint with typescript-eslint: Type-Aware Linting
Testing with Vitest: Unit Tests, Mocks and Type Tests
Migrating from JavaScript to TypeScript: A Step-by-Step Strategy
Common TypeScript Mistakes
Project: Migrating a JavaScript App to TypeScript
Final Project: A Full-Stack TypeScript Application

TypeScript course · Generics

Practice: A Typed EventEmitter

🔒 This is the beginning of the lesson. The full lesson is available with a subscription.

Create account Log in

← Previous lesson🔒 Generic Higher-Order Functions and Variadic Tuples Next lesson →🔒 Utility Types: Partial, Required and Readonly

PROWIDIT Education Academy

Online programming courses in Baku. Live lessons in Azerbaijani and Russian, 80% practice, mentor support and job placement assistance.

Front End

HTML & CSS JavaScript TypeScript React Next.js Vue.js

Back End

SQL (PostgreSQL, MySQL) PHP Laravel Python Algorithms Django & FastAPI Node.js Full Stack

Tools & AI

Git & GitHub Docker & deployment AI for developers

Useful links

Free trial lesson Mentoring & interviews For companies Blog FAQ

Contacts

+994 77 333 38 36 info@prowid.com Video lessons Send a request

© 2021–2026 Prowid — IT Education Academy. All rights reserved. Baku, Azerbaijan