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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- A type is the category or classification: number, string, boolean.
- Lesson 93 — Literal Values vs Type NamesLesson 413 — Common Discriminant NamesLesson 447 — Intersection Order Independence
- 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 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
- 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
- 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