← Back to TypeScript

TypeScript Glossary

Key terms from the TypeScript course, linked to the lesson that introduces each one.

227 terms.

A

Abstract members
Abstract members are contracts — methods and properties marked with the abstract keyword that your subclass must implement.
Lesson 1053 — Extending Abstract Classes
access modifier
The access modifier is the locked door (who can enter the room)
Lesson 1040 — Combining readonly with Access Modifiers
accumulator
In type-level programming, an accumulator is a type parameter that collects results as you recurse through a structure.
Lesson 1467 — Type-Level Accumulators
Always use lowercase type names
number, string, boolean, symbol, and bigint. Never use the capitalized object wrapper types unless you explicitly need an object wrapper (which is extremely rare in modern code).
Lesson 96 — Primitive Wrappers: Number, String, Boolean
any
any is like assuming the box contains exactly what you need and using it immediately—no questions asked
Lesson 139 — Comparing any, unknown, and neverLesson 886 — unknown vs any: The Key Safety DifferenceLesson 906 — Type Safety Trade-offs
any string key
The index signature is like saying: "This object is a container where any string key is allowed, but every value must be the same type." It's a pattern match for the entire object's structure.
Lesson 311 — Basic Index Signature Syntax
API responses
network data is inherently untyped
Lesson 936 — unknown for External Data Entry Points
Arity
Arity refers to the number of parameters a function accepts.
Lesson 274 — Overloading by Arity
ArkType
ArkType is the newest contender, focused on runtime performance:
Lesson 1295 — Alternatives: Yup, io-ts, ArkType
Arrays
Arrays are variable-length collections where every element has the same type (homogeneous)
Lesson 124 — Tuples vs ArraysLesson 1370 — Tuple Types vs Array Types
as const
as const is a type assertion you apply to values.
Lesson 473 — as const vs readonly Modifiers
assertion debt
Just like technical debt, assertion debt is the accumulated cost of type assertions (as, !, double assertions) that weaken type safety.
Lesson 1017 — Measuring Assertion Debt in Your Codebase
Assign to any or unknown
these are the only types that accept anything
Lesson 887 — Basic Operations on unknown Values
Assignability relationships
Whether type A is assignable to type B
Lesson 1704 — The Type Cache and Memoization

B

base case
A base case is a condition where the type stops referring to itself.
Lesson 1742 — Avoid Recursive Types Without Base Cases
baseUrl
The root directory for all non-relative imports. Paths are resolved relative to this.
Lesson 1118 — baseUrl and paths for Custom Mappings
Best for
Migration shims, framework internals where types are provided separately, or when wrapping truly dynamic systems where forcing narrowing would be impractical.
Lesson 909 — Return Types: When Each Makes Sense
Beta releases
Beta releases are more stable previews, typically 2-4 weeks before a final release.
Lesson 1780 — Features in Active Development
Blazing fast startup
Bun's transpiler is written in highly optimized code (Zig language), making it significantly faster than alternatives
Lesson 71 — Running TypeScript in Bun
boolean
In TypeScript (and most programming languages), a boolean is a data type that can only hold one of two values: true or false.
Lesson 86 — The boolean Type
bottom type
In type theory, the bottom type is a type that has no values.
Lesson 944 — The Bottom Type Concept
Bottom-up migration
Bottom-up migration means starting with low-level utility functions and data structures that other parts of your code depend on.
Lesson 1599 — The Bottom-Up vs Top-Down Decision
branded type
A branded type is a type that carries a compile-time "tag" or "brand" to distinguish it from other structurally identical types.
Lesson 658 — Branded Type Constraints
But structural compatibility remains
Both are still compatible with plain string
Lesson 1357 — Flavoring vs Full Branding

C

changed files and their dependents
With .tsbuildinfo, only changed files and their dependents are reprocessed, cutting build times from minutes to seconds in large projects.
Lesson 1225 — The .tsbuildinfo File
Clearer boundaries
Only the public API (what's exported) is visible, enforced by declarations
Lesson 1227 — Cross-Project Imports
Community Outreach
Major changes are announced in blog posts, Twitter threads, and Discord discussions well before release.
Lesson 1785 — Community Feedback and Breaking Changes
Compile-time errors
Compile-time errors are like spelling and grammar mistakes you catch before submitting—your spell-checker flags them immediately.
Lesson 2 — Runtime Errors vs Compile-Time Errors
Complex module resolution
Searching node_modules hierarchies is expensive
Lesson 1710 — Symbol Table Lookups and Resolution
Concrete members
Concrete members are ready-to-use — methods and properties that already have implementations.
Lesson 1053 — Extending Abstract Classes
concrete type
In TypeScript, a concrete type is a fully instantiated type you can actually use: Array<number>, Promise<string>, Set<User>.
Lesson 1493 — Concrete Types vs Abstract Type Constructors
Conditional chaining
Conditional chaining means your methods selectively return this based on runtime logic, while TypeScript still tracks the type correctly.
Lesson 1079 — Conditional Chaining with this
Conditional types
Conditional types are impossible in JSDoc.
Lesson 1640 — JSDoc Limitations vs Native TypeScript
connected
the active socket and timestamp
Lesson 1343 — Connection State Machines
const enum
A const enum is a special variation of an enum that gets completely erased during compilation.
Lesson 499 — What const enums Are
const enums
Remember that const enums are completely inlined at compile time — the compiler replaces every reference with the actual value.
Lesson 1255 — Const Enums Break Without Cross-File Context
constrained generics
Think of it like a security checkpoint: generics are like "anyone can pass through," unions are like "only these three people exist," but constrained generics are "preserve each person's identity, but only let these three through."
Lesson 1666 — Generic Constraints vs Union Bounds
Constraint solving
Constraint solving is the algorithmic process where TypeScript examines all the contexts where a type parameter appears, collects requirements (constraints), and finds a type that satisfies all of them simultaneously.
Lesson 1702 — Constraint Solving and Unification
context type propagation
In tRPC, context type propagation refers to how the type of your context object automatically flows through every procedure in your router.
Lesson 1575 — Context Type Propagation
contextual typing
Top-down inference (also called contextual typing) starts with an expected type based on where a value is being used, then flows that type information downward into the expression.
Lesson 168 — Function Parameter ContextLesson 245 — Typing Anonymous FunctionsLesson 1700 — Type Inference Flow: Bottom-Up and Top-Down
Contravariance
Contravariance means that function parameters vary in the opposite direction of assignability:
Lesson 1197 — strictFunctionTypes: Contravariant Function Parameters
control flow analysis
This is called control flow analysis—TypeScript traces through your if/else statements to determine what's possible where.
Lesson 102 — Type Guards for PrimitivesLesson 1709 — Control Flow Analysis Overhead

D

Declaration merging
Declaration merging is TypeScript's ability to take multiple interface declarations with the same name and merge them into a single interface containing all properties from each declaration.
Lesson 371 — Declaration Merging: The Key Interface Superpower
declare var
The variable can be reassigned
Lesson 1151 — Declaring Global Variables
declared unique symbol
A declared unique symbol is a type created with two keywords working together:
Lesson 1351 — Declaring Brand Symbols
Decorator context object
Decorator context object is now the primary way to access metadata
Lesson 1784 — Decorator Standardization Progress
DefinitelyTyped
For JavaScript libraries that don't include their own types, the community maintains type definitions in a massive repository called DefinitelyTyped.
Lesson 34 — TypeScript in Package EcosystemsLesson 1131 — DefinitelyTyped and @types Packages
Design Meetings
Notes from weekly design meetings are published publicly, showing the reasoning behind decisions. Community members can see why a feature works a certain way.
Lesson 1785 — Community Feedback and Breaking Changes
Destructured values without context
The structure doesn't tell TypeScript what types are inside
Lesson 1200 — noImplicitAny: Banning Implicit any Types
Diminishing returns
The workarounds you've learned (interface pattern, lightweight tricks) handle the rare cases where HKTs matter. Native support would add significant compiler complexity for edge-case benefits.
Lesson 1494 — The TC39 and TypeScript Roadmap on HKTs
disconnecting
the socket being closed and why
Lesson 1343 — Connection State Machines
discriminant
A discriminant property (also called a discriminant or tag) is a common property that exists on all union members, where each member has a different literal value for that property.
Lesson 399 — Narrowing with Discriminant Properties
discriminant property
A discriminant property is a unique property that exists on one union member but not others (or has a unique literal value).
Lesson 226 — Type Predicates for Union Narrowing
discriminated unions
Enums create actual JavaScript objects at runtime (in most cases), while discriminated unions are pure type-level constructs that compile away completely.
Lesson 414 — Discriminated Unions vs Enums
distribution
This is called distribution, and it happens automatically.
Lesson 820 — Combining String Literal Types
Documents intent
the name explains what the union represents
Lesson 353 — Aliasing Union Types
dts-gen
dts-gen is a tool that generates .d.ts declaration files by analyzing JavaScript modules at runtime.
Lesson 1648 — Alternative Tools: dts-gen and Others
Dynamic typing
Dynamic typing means types are checked while the program is running.
Lesson 1 — What is Static Typing?

E

Either
A Result (also called Either) is a generic type that represents an operation that could succeed with a value or fail with an error.
Lesson 594 — Generic Result/Either Types
Enums
Enums are useful when you need runtime iteration, reverse lookups, or want autocomplete on a dedicated namespace.
Lesson 481 — Literal Unions vs Enums: Trade-offs
esbuild
esbuild is the speed demon—written in Go, it can transpile TypeScript 10-100x faster than traditional tools.
Lesson 35 — Build Tools and TypeScriptLesson 1234 — Bundlers: Webpack, Rollup, esbuild, and Others
event types themselves
The challenge is ensuring both the event data shape and the event types themselves are fully type-safe across the network boundary.
Lesson 1549 — Subscription Procedures with Event Types
exactly which keys
Record<Keys, Value> lets you specify exactly which keys are allowed while keeping all their values the same type:
Lesson 317 — Index Signatures and Record Utility
exhaustive check
An exhaustive check is a compile-time pattern that ensures you've handled all members of a union type.
Lesson 954 — What Is an Exhaustive Check?
exhaustive switching
This is called exhaustive switching — ensuring your code accounts for all cases without accidentally leaving gaps.
Lesson 1337 — Exhaustive Switching on State
exhaustiveness checking
This is called exhaustiveness checking — making sure you haven't forgotten any possibilities.
Lesson 206 — Switch Statement Exhaustiveness
expected type
But because the expected type is the union Color, it narrows to the matching literal.
Lesson 173 — Contextual Union Types
Explicit annotation
Explicit annotation means writing out the TypeScript type first, then building a schema that matches it.
Lesson 1309 — When to Explicitly Annotate vs Purely Infer

F

Fail loudly
The throw ensures bad data never leaks through
Lesson 934 — Generic parseResponse Helper Function
Fewer escape hatches
TypeScript's any type essentially turns off type checking. Hegel is more restrictive about bypassing its rules.
Lesson 27 — Hegel: A Stronger Type System for JavaScript
Function overloads
Function overloads are explicit: you list out each signature combination one by one.
Lesson 277 — Overloads vs Conditional Types
Function parameters
Function parameters are the most common culprits:
Lesson 1672 — Implicit any from Missing Type Annotations
Function return types
A library returns any, so you don't know what you're getting
Lesson 884 — any in Third-Party Libraries

G

generic class property
A generic class property is a property whose type isn't fixed when you define the class — instead, it's determined by a type parameter that gets specified when you create an instance.
Lesson 1028 — Generic Class Properties
Generic classes
Generic classes are best when you need to store and manage state across multiple operations
Lesson 562 — When to Use Generic Classes vs Functions
Generic conditional types
Generic conditional types are dynamic: you write a single signature with a type that branches based on generic type parameters.
Lesson 277 — Overloads vs Conditional Types
generic function
A generic function is a function that uses type parameters to work with different types while preserving full type information.
Lesson 537 — What Are Generic Functions?
Generic functions
Generic functions are best for stateless, single operations that transform or process data
Lesson 562 — When to Use Generic Classes vs Functions
Generic instantiations
The result of applying type arguments to generic types
Lesson 1704 — The Type Cache and Memoization
generic interface
A generic interface is an interface that accepts one or more type parameters, making it reusable for different data types while maintaining type safety.
Lesson 551 — Generic Interfaces: Basics
gradual migration philosophy
The gradual migration philosophy means converting your JavaScript codebase to TypeScript piece by piece, file by file, while keeping everything running and deployable at every step.
Lesson 1591 — The Gradual Migration Philosophy
GraphQL Codegen
GraphQL Codegen is the right choice when you've already committed to GraphQL.
Lesson 1589 — When to Choose Each Approach

H

higher-order function
A higher-order function is a function that either takes a function as an argument or returns a function as its result.
Lesson 586 — Higher-Order Functions
HKT simulation
HKT simulation is TypeScript's workaround for expressing relationships between type constructors themselves—not just between concrete types.
Lesson 1495 — What HKT Simulation Means in TypeScript
homomorphic mapped types
These are called homomorphic mapped types — they maintain the "shape" of the input type.
Lesson 1720 — Homomorphic vs Non-Homomorphic Mapped Types
Hot types
Hot types are the types that take the longest to instantiate or check.
Lesson 1729 — Identifying Hot Types in Traces

I

Idempotency
Idempotency means an operation can be performed multiple times with the same result.
Lesson 1566 — Idempotency and Query vs Mutation Choice
identity function
The identity function is a function that takes a value and returns that exact same value unchanged.
Lesson 590 — The Identity Generic: <T>(x: T) => TLesson 609 — The Identity Function Pattern
Immediate user impact
Entry points are where bugs hurt most
Lesson 1599 — The Bottom-Up vs Top-Down Decision
implicit any
This is called implicit any, and it's particularly sneaky because you don't see the word any anywhere in your code—TypeScript just quietly stops checking.
Lesson 883 — Implicit any from Missing Types
Improves readability
Result is clearer than Success | Failure
Lesson 353 — Aliasing Union Types
Index signatures
Index signatures are for objects where you genuinely don't know what the keys will be at compile time.
Lesson 319 — Index Signatures vs Mapped Types
inference at the call site
This is called inference at the call site.
Lesson 532 — Generic Type Inference at Call Sites
Inference fails
The type parameter doesn't appear in function arguments
Lesson 570 — When to Use Defaults vs Required Parameters
Inline annotations
Inline annotations (Approach 1) are more common and feel natural.
Lesson 237 — Arrow Function Type Annotations
Input
The shape of incoming data (params, query, body, headers)
Lesson 1533 — Hono's Type-Safe Request Context
Instant
An exact moment in universal time
Lesson 1761 — Temporal API and Date Type Safety
IntelliSense
This real-time assistance is called IntelliSense or autocomplete.
Lesson 4 — Autocomplete and IntelliSense Benefits
interface
An interface is a named structure that describes the shape of an object.
Lesson 338 — What Interfaces AreLesson 339 — Basic Interface Syntax
interfaces
Interfaces are pure contracts — they only describe what properties and methods must exist, without providing any implementation.
Lesson 340 — Interface vs Object Type LiteralLesson 1052 — Abstract Classes vs Interfaces

J

JavaScript alignment
TypeScript's guiding principle is to track JavaScript's evolution. HKTs have no runtime counterpart and wouldn't help developers write better JavaScript—they'd only exist at the type level.
Lesson 1494 — The TC39 and TypeScript Roadmap on HKTs
JSDoc
JSDoc is a commenting system that describes what types functions expect and return.
Lesson 26 — JSDoc Type Annotations in Plain JavaScript

L

leaves
The leaves are files that import many things but are themselves rarely imported.
Lesson 1616 — Choosing Which Files to Convert First
literal type
A literal type is a type that represents one exact value.
Lesson 457 — What Are Literal Types?
lookup type
This is called a lookup type or indexed access type.
Lesson 640 — Lookup Types: T[K] After keyof Constraint
Low-risk
DOM queries where element existence is guaranteed
Lesson 1017 — Measuring Assertion Debt in Your Codebase

M

MAJOR
Represents breaking changes (very rare in TypeScript)
Lesson 1777 — Understanding TypeScript's Release Cadence
mapped type
A mapped type is TypeScript's way of creating a new type by transforming each property in an existing type.
Lesson 717 — What Are Mapped Types?
Mapped types
Mapped types are for transforming a known set of keys in a systematic way.
Lesson 319 — Index Signatures vs Mapped Types
Memoization
Memoization is the pattern of caching a function's results so repeated calls with the same arguments return cached values instead of recomputing.
Lesson 598 — Generic Cache and Memoization
message
A string description of what went wrong
Lesson 1577 — Error Type Inference and Handling
Method syntax
Method syntax is cleaner and matches how you typically write object methods.
Lesson 292 — Function Properties in Object Types
Missing or incomplete type definitions
The library exists, but types are an afterthought
Lesson 884 — any in Third-Party Libraries
module resolution
This process is called module resolution, and TypeScript has two different algorithms for doing it: Classic and Node.
Lesson 1111 — Classic vs Node Resolution Strategies
monkey-patching
This practice—often called monkey-patching—lets you add methods or properties to existing types after they're defined.
Lesson 1629 — Prototype Manipulation and Monkey-Patching
monorepo
A monorepo is a single repository containing multiple related projects—think shared utility libraries, core business logic packages, and several applications (web, mobile, admin) that consume them.
Lesson 1229 — Monorepo Patterns with References
mutations
In tRPC, queries are procedures that fetch data without changing server state, while mutations are procedures that modify server state.
Lesson 1544 — Mutation Procedures with Input TypesLesson 1561 — What Distinguishes Queries from Mutations

N

naked type parameter
A naked type parameter means the type parameter appears directly, without being wrapped in any other type structure like an array, tuple, or object.
Lesson 779 — What Makes a Conditional Type Distributive
NarrowerType
The specific type you're confirming
Lesson 222 — Basic Type Predicate Syntax
nested conditional type
A nested conditional type is simply a conditional type where the true or false branch (or both) contains another conditional type.
Lesson 771 — Nested Conditional Types
nested object type literal
A nested object type literal is when you define the type of a property to be another complete object type, rather than just a primitive like string or number.
Lesson 291 — Nested Object Type Literals
no imports or exports
By default, a declaration file (.d.ts) that contains no imports or exports is treated as a script file.
Lesson 1159 — export {} to Force Module Context
No null or undefined surprises
The language handles "nothing" values more safely by design
Lesson 24 — ReasonML and ReScript: OCaml-Based Alternatives
No runtime errors
if it compiles, entire categories of bugs are impossible
Lesson 25 — PureScript and Elm: Pure Functional Alternatives
No runtime lookups
JavaScript doesn't need to find a property on an object. The value is already there, hardcoded into your code.
Lesson 502 — Performance Benefits of const enums
No structure
Everything is one flat list with no semantic grouping
Lesson 1653 — Discriminated Unions vs Flat String Unions
nodemon
nodemon is a tool that watches your files and automatically restarts your Node.js process when changes are detected.
Lesson 69 — nodemon with ts-node for Auto-Restart
Non-relative imports
Non-relative imports are resolved against configured paths.
Lesson 1113 — Relative vs Non-Relative Imports
numeric enum
A numeric enum is TypeScript's built-in way to create a set of named constants that map to numeric values.
Lesson 487 — Basic Numeric Enum Syntax

O

opaque type
An opaque type is a type that reveals only its interface—what you can do with it—while completely hiding how it's implemented underneath.
Lesson 1360 — What Opaque Types Are
Overloads
Overloads are more precise—they let you express relationships between specific input types and their corresponding output types.
Lesson 278 — Overloads vs Union Parameters

P

parameter
Its parameter is typed as never (only accepts the impossible)
Lesson 955 — The Basic Exhaustive Check Pattern
Parameter typed as never
This means TypeScript expects no valid value can ever be passed. If you can pass something, TypeScript flags it as an error.
Lesson 956 — Creating an assertNever Helper
Path
The literal route pattern string (e.g., "/users/:id")
Lesson 1533 — Hono's Type-Safe Request Context
Pattern matching
A powerful way to handle different data shapes
Lesson 24 — ReasonML and ReScript: OCaml-Based Alternatives
phantom type
A phantom type is a generic type parameter that doesn't appear in the actual runtime value structure—it only exists at the type level to carry information.
Lesson 1356 — Phantom Types for StateLesson 1428 — The Phantom Type Builder Pattern
pnpm
yarn and pnpm are popular alternatives that offer different performance characteristics and dependency management approaches.
Lesson 43 — Using yarn and pnpm for TypeScript
Predictable
The semantics are straightforward
Lesson 1512 — Keep Types Simple and Composable
Preserving
Preserving means distributing your mapping operation across each union member individually, maintaining the union shape in the output.
Lesson 738 — Preserving vs Transforming Union Members
private
a TypeScript-only keyword that disappears after compilation. It provides compile-time safety but no runtime privacy.
Lesson 1037 — Comparing private vs # Private Fields
Property syntax
Property syntax is useful when you need to emphasize that a function is just a value being stored, or when dealing with optional function properties.
Lesson 292 — Function Properties in Object Types
Pure inference
Pure inference means your schema is the single source of truth.
Lesson 1309 — When to Explicitly Annotate vs Purely Infer

Q

queries
In tRPC, queries are procedures that fetch data without changing server state, while mutations are procedures that modify server state.
Lesson 1561 — What Distinguishes Queries from MutationsLesson 1562 — tRPC query() Method Basics

R

readonly
The readonly is the glass case (even if you're in the room, you can't touch the artifact)
Lesson 473 — as const vs readonly ModifiersLesson 1040 — Combining readonly with Access Modifiers
readonly array
A readonly array is an array type that TypeScript treats as immutable.
Lesson 108 — Readonly Arrays
real fix
The real fix is to convert the number to a string properly or accept that these types are incompatible.
Lesson 1011 — Assertions That Hide Real Type Errors
recursive type alias
A recursive type alias is a type that references its own name in its definition.
Lesson 356 — Recursive Type Aliases
Recursive type aliases
Recursive type aliases are extremely limited or unsupported in JSDoc.
Lesson 1640 — JSDoc Limitations vs Native TypeScript
Reduced bundle size
No enum object means fewer bytes shipped to users. For large enums used frequently, this adds up.
Lesson 502 — Performance Benefits of const enums
Reduced context switching
Error location, message, and code are all in one view
Lesson 1270 — Reporting Type Errors in Pull Requests
Reduced tooling burden
Fewer moving parts means fewer things to break, configure, or understand. The barrier to entry drops dramatically.
Lesson 1768 — The Motivation: Types Without Transpilation
RefType
RefType is what the ref points to (usually an HTMLElement), and PropsType defines the component's props.
Lesson 1527 — Typing forwardRef for Ref-Forwarding Components
Relative imports
Relative imports are resolved relative to the importing file's location.
Lesson 1113 — Relative vs Non-Relative Imports
Repeated narrowing
The same variable checked multiple times in different ways
Lesson 1709 — Control Flow Analysis Overhead
repository pattern
The repository pattern is a data access layer that sits between your application logic and your database.
Lesson 592 — Generic Repository Pattern
return type
Its return type is never (never returns normally)
Lesson 955 — The Basic Exhaustive Check Pattern
Return type never
The function never returns normally—it always throws.
Lesson 956 — Creating an assertNever Helper
Runtime errors
Runtime errors are like factual mistakes that only become obvious after someone reads your essay—by then, it's already published and embarrassing.
Lesson 2 — Runtime Errors vs Compile-Time Errors
Runtime safety
Clear error if provider is missing
Lesson 1526 — Typing Context Providers with createContext
Rust
Rust is exploring HKTs through Generic Associated Types (GATs)
Lesson 1488 — Languages That Have HKTs

S

Safe narrowing
Inside the if, TypeScript knows data is T, so the return is type-safe
Lesson 934 — Generic parseResponse Helper Function
Script files
Files with no imports or exports. Everything declared in them is automatically global.
Lesson 1177 — Placement and Module Context
shape
The formatted error matching your server's error formatter
Lesson 1577 — Error Type Inference and Handling
Shows helpful hints
Hover over something to see what type it is and how to use it
Lesson 4 — Autocomplete and IntelliSense Benefits
Slow to compile
The compiler must recursively evaluate complex type expressions, dramatically increasing compilation time
Lesson 1503 — The Complexity Tax of HKT Simulation
Small codebases
Small codebases are the obvious candidate.
Lesson 1620 — When All-at-Once Actually Works
smart constructor
A smart constructor is a function that combines runtime validation with compile-time type branding.
Lesson 1363 — Smart Constructor Functions
Soundness
Soundness means the type system guarantees your code will never have certain categories of runtime errors.
Lesson 27 — Hegel: A Stronger Type System for JavaScript
source map
A source map is a special file (.js.map) that acts like a translator between your compiled JavaScript and your original TypeScript source.
Lesson 61 — sourceMap: Debugging Compiled Code
static initialization block
A static initialization block is a special code block inside a class that runs exactly once when the class is first evaluated, before any instances are created.
Lesson 1059 — Static Blocks for Initialization
static properties
In TypeScript (and JavaScript), static properties are properties that exist on the class constructor itself, not on objects created from that class.
Lesson 1056 — Static Properties Basics
Static typing
Static typing means your code's types are checked before the program runs.
Lesson 1 — What is Static Typing?
strictFunctionTypes
Ensures function parameter types are checked correctly (contravariance)
Lesson 1180 — What strict Mode Does
Strictness Expansion
New flags like noUncheckedIndexedAccess are opt-in, but they reveal problems in existing code when enabled.
Lesson 1785 — Community Feedback and Breaking Changes
String Enums
String Enums are nominal types at the type level — only actual enum members can be assigned:
Lesson 518 — Type Safety: Enums vs Unions
string literal types
These are called string literal types, and they look like this:
Lesson 458 — String Literal Types Syntax
String-Literal Unions
String-Literal Unions are structural — any matching string literal works:
Lesson 518 — Type Safety: Enums vs Unions
Stronger guarantees
The type system catches more errors at compile time
Lesson 24 — ReasonML and ReScript: OCaml-Based Alternatives
structural typing
This is called structural typing (or "duck typing" at the type level).
Lesson 1703 — Structural Type Checking Mechanics
stub
A stub is a bare-minimum .d.ts file that declares just enough about a module to satisfy the TypeScript compiler.
Lesson 1598 — Creating .d.ts Stubs for Dependencies

T

Template literal types
Template literal types are not supported.
Lesson 1640 — JSDoc Limitations vs Native TypeScript
Temporal API
The Temporal API is a Stage 3 TC39 proposal that will introduce a suite of immutable, strongly-typed objects for working with dates and times.
Lesson 1761 — Temporal API and Date Type Safety
Third-party code integration
Third-party code integration is blocking your migration path
Lesson 1004 — Progressive Migration Scenarios
top type
In type theory, a top type is a type that can accept any value from the entire type system.
Lesson 903 — unknown as a Top Type
Top-down migration
Top-down migration means starting with entry points like main.ts, route handlers, or application controllers.
Lesson 1599 — The Bottom-Up vs Top-Down Decision
Tradeoff
You might miss some type errors if your dependencies have incorrect or conflicting type definitions, but this is rare and the performance gain is almost always worth it.
Lesson 84 — The --skipLibCheck Flag: Skipping node_modules Types
Transforming
Transforming means treating the entire union as a single entity and applying an operation that collapses or changes the overall structure.
Lesson 738 — Preserving vs Transforming Union Members
tRPC
tRPC is ideal when you control both sides of the stack and work in a TypeScript-only environment.
Lesson 1589 — When to Choose Each Approach
Trust
Published libraries are usually already type-checked by their maintainers
Lesson 84 — The --skipLibCheck Flag: Skipping node_modules Types
ts-loader
ts-loader is a Webpack loader that uses the actual TypeScript compiler (tsc) under the hood.
Lesson 1237 — Bundler Loaders: ts-loader and babel-preset-typescript
ts-migrate
ts-migrate is an automated migration tool created by Airbnb that solves this problem by batch-converting JavaScript files to TypeScript with minimal human intervention.
Lesson 1643 — What ts-migrate Does
ts-node
ts-node is a tool that combines both steps into one.
Lesson 66 — Running with ts-node
tsserver
Instead, a separate program called tsserver (the TypeScript language service) runs in the background as a long-lived process.
Lesson 1748 — The Language Service Architecture
tuple
A tuple is an array with a fixed number of elements where each position has a specific, known type.
Lesson 116 — What Tuples Are and When to Use Them
Tuples
Tuples are fixed-length collections where each position can have a different type (heterogeneous)
Lesson 124 — Tuples vs ArraysLesson 1370 — Tuple Types vs Array Types
type alias
A type alias is simply a name you create for any type.
Lesson 348 — What Is a Type Alias?
type annotation
A type annotation is like a label you attach to a variable, telling TypeScript: "This box can only hold this specific kind of value." You write it using a colon (:) followed by the type name.
Lesson 92 — Type Annotations for Primitives
Type Annotations Proposal
The Type Annotations Proposal is a TC39 proposal to add type syntax directly to JavaScript — but with a crucial twist: JavaScript engines would completely ignore the types at runtime.
Lesson 1767 — What the Type Annotations Proposal Is
type argument inference
Think of it like a detective examining clues: if you hand a function the number 42, TypeScript concludes "Ah, T must be number!" This process is called type argument inference.
Lesson 599 — When TypeScript Infers Type Arguments
type guard
A type guard is a runtime function that actually checks if the data matches your expected shape.
Lesson 1276 — Type Guards for Response Validation
Type identity checks
Whether two types are identical
Lesson 1704 — The Type Cache and Memoization
Type inference
Type inference means TypeScript examines your code and determines what types your variables should have — without you explicitly writing type annotations.
Lesson 141 — What Is Type Inference?
type narrowing
Type narrowing is TypeScript's ability to refine a union type (like string | number) into a more specific type (like just string) when you perform checks like typeof or conditionals.
Lesson 132 — Narrowing unknown with typeofLesson 189 — What Is Type Narrowing?
type predicate
A type predicate is a special return type for functions that tells TypeScript: "If this function returns true, then the value is definitely this specific type."
Lesson 221 — What Type Predicates AreLesson 398 — Type Predicates for Custom NarrowingLesson 918 — Type Predicates for Custom Narrowing
Type predicate parameter
validator: (value: unknown) => value is T tells TypeScript "if this returns true, narrow to T"
Lesson 934 — Generic parseResponse Helper Function
Type preservation
The exact input type flows through (generic behavior)
Lesson 1666 — Generic Constraints vs Union Bounds
Type safety
The types condition ensures TypeScript always finds the right .d.ts files
Lesson 1116 — The exports Field for Modern Packages
Type-first annotations
Type-first annotations (Approach 2) are useful when you're implementing a specific function signature or want to reuse the type.
Lesson 237 — Arrow Function Type Annotations
type-level apply function
A type-level apply function is the bridge.
Lesson 1497 — Type-Level Apply Functions
Type-level programming
Type-level programming means writing logic that exists only in the type system.
Lesson 1463 — What Is Type-Level Programming?
Type-level programming patterns
treating types like functions that compute other types — are essentially off the table.
Lesson 1640 — JSDoc Limitations vs Native TypeScript
type-safe validator
A type-safe validator is a function that takes unknown input (representing data you don't trust yet—like JSON from an API or user input) and either:
Lesson 941 — unknown in Type-Safe Validators
TypeScript Playground
an in-browser editor where you can write TypeScript and instantly see the compiled JavaScript alongside type errors
Lesson 39 — Community Resources and Learning

U

undefined
undefined is an actual value that exists
Lesson 944 — The Bottom Type Concept
Under 50 files
Manual migration is almost certainly faster and produces better results.
Lesson 1649 — When Automation Helps vs Manual Migration
Unification
Unification is the mechanism for making two types "match" by finding substitutions for type parameters.
Lesson 1702 — Constraint Solving and Unification
Union explosion
A type that generates hundreds of union members slows down checking for every variable using that type
Lesson 1472 — Limits of Type-Level Computation
Union parameters
Union parameters are simpler—they say "this parameter can be type A OR type B." You write one function signature with union types in the parameters and/or return type.
Lesson 278 — Overloads vs Union Parameters
union type
A union type represents a value that could be one of several different types.
Lesson 382 — What Union Types Are
Unique
Every symbol is different from every other symbol
Lesson 90 — The symbol Type
unknown
unknown is like acknowledging you don't know what's in the box, so you must open it and check before using the contents
Lesson 139 — Comparing any, unknown, and neverLesson 886 — unknown vs any: The Key Safety DifferenceLesson 906 — Type Safety Trade-offs

V

value
Think of it like a label on a jar: the label is the name ("Sugar"), but the value is what's actually inside the jar (maybe the string "SUGAR" or the number 0).
Lesson 93 — Literal Values vs Type NamesLesson 497 — Enum Member Name vs Value
Variables without initialization
Variables without initialization are another source: if you declare a variable without assigning a value or providing a type annotation, TypeScript has nothing to work with and defaults to any.
Lesson 1672 — Implicit any from Missing Type Annotations
void
void means "no useful return value" — the function completes, just with nothing meaningful
Lesson 944 — The Bottom Type Concept

W

widening
This is called widening—TypeScript assumes you might reassign the variable later, so it gives you flexibility.
Lesson 163 — Literals and Widening: When Inference Hurts

Z

Zod
Zod is a TypeScript-first schema validation library that lets you declare what your data should look like, then automatically validates it and provides full type safety—all in one step.
Lesson 932 — Integrating Zod for unknown Validation