tsconfig & Compilation

allowSyntheticDefaultImports is type-checking only: it lets you write a default import from a module that declares no default export. esModuleInterop additionally changes CommonJS emit to wrap the required value, and it turns allowSyntheticDefaultImports on for you.

useDefineForClassFields switches class field emit from plain assignment to Object.defineProperty semantics, matching the ECMAScript standard. It defaults to true when target is ES2022 or higher. Fields declared without an initializer then overwrite inherited values with undefined, and they shadow base-class accessors instead of calling them.

At an ES5 target TypeScript compiles for...of over arrays and strings into a plain index loop, which cannot work for a Map. downlevelIteration makes the compiler emit helpers that call Symbol.iterator instead, so any iterable works — but the runtime must actually provide Symbol.iterator.

exactOptionalPropertyTypes separates absent from present-and-undefined. With it on, retries?: number means the property may be missing but must hold a real number when present, so assigning { retries: undefined } is an error; declare retries?: number | undefined to allow both.

noImplicitOverride requires the override keyword on any member that redefines a concrete member inherited from a base class, including properties and accessors. It catches renamed or deleted base members, whose overrides would otherwise silently become brand-new members.

With noUncheckedIndexedAccess on, every read through an array index or an index signature gains undefined: rows[0] is string | undefined rather than string. Declared properties, fixed tuple positions and for...of iteration are unaffected.

A const enum is normally compiled away by inlining its member values, which requires reading the declaring file. An ambient const enum emits no runtime object at all, so a tool that reads one file has nothing to inline and nothing to reference — hence the error.

verbatimModuleSyntax replaces import elision with one syntactic rule: anything written with a type modifier is dropped entirely, and everything else is emitted exactly as written. Added in TypeScript 5.0, it supersedes importsNotUsedAsValues and preserveValueImports.

Under strict, the useUnknownInCatchVariables flag types a catch clause variable as unknown rather than any, so reading any property off it is a compile error. You must narrow first — typically with an instanceof Error check — before touching e.message.

The strictPropertyInitialization flag, enabled by strict and requiring strictNullChecks, produces that error. Satisfy it by giving the field an initializer, assigning it unconditionally in the constructor, or admitting it may be missing by making the type optional or including undefined.

Run tsc -b --verbose to see why each project is considered out of date. Typically CI restores neither the .tsbuildinfo files nor the emitted outputs, or a fresh checkout resets file timestamps, or a changed compiler version or config invalidates the recorded build state.

Start with tsc --extendedDiagnostics for a breakdown of parse, bind, check and emit time plus file, type and instantiation counts. Then use --generateTrace with @typescript/analyze-trace to find the specific files and types that dominate checking.

Nothing. An ambient declaration is an unverified promise to the type checker; it emits no JavaScript and never checks that the thing exists. Guarantees have to come from the build or from a runtime-validated module, not from the declaration.

Under node16 resolution, an exports map takes over entry-point resolution and the top-level types field is no longer consulted. Add a types condition inside exports, listed first in each condition object, or place a matching .d.ts beside every resolved JavaScript file.

Do not merge the all-at-once change. Stage it: keep strict on but switch individual flags back off and re-enable them one at a time, or scope strict to migrated directories, and make CI hold a baseline error count that is only ever allowed to fall.

node10 is the legacy resolution algorithm: it walks node_modules by directory and file name and ignores package.json exports entirely, so a subpath declared only there is invisible to the compiler. node16, nodenext and bundler read exports maps.

By default the compiler inlines its downleveling helpers into every file that needs them. importHelpers makes it import them from the tslib package instead, so they exist once. tslib then becomes a real runtime dependency, which a published library must list under dependencies.

Measure each flag's error count first by enabling it alone on the command line, then adopt one flag per change. Expect noUncheckedIndexedAccess to dominate, since it touches every array index and dictionary lookup, and watch that its fixes are real checks rather than assertions.

tsc reads ./config, sees Config is an interface, and drops it from the re-export. A per-file transpiler never reads that file, so it emits a real re-export of a binding that the emitted config.js does not have. Fix it with export type, and enable isolatedModules so the compiler catches every such site.

Split the work by flag and by file. Enable the cheap members of the strict family first, then adopt strictNullChecks and noImplicitAny through a second tsconfig that extends the base, sets strict, and lists a growing set of already-clean files that CI checks alongside the loose build.

Global augmentation is convenient but unscoped and unverified: the property appears on every request in every file whether or not the middleware ran. Prefer it only for genuinely universal, optional data, and use distinct types or an explicit context for anything a handler must be able to rely on.

Incremental is the default because the codebase stays shippable and every step is revertable. A rewrite is only defensible for a small, stable, well-covered module. Staying on typed JavaScript is the right answer when the build cannot change or the code ships as source.

Pick target from the oldest runtime that must execute the emitted code, and lib from the APIs that runtime actually provides plus any polyfills you ship. The compiler downlevels syntax only: it never polyfills built-ins, and the lib you choose leaks into your published types as a requirement on consumers.

path pulls another file into the compilation, types declares a dependency on a package's ambient type declarations, and lib pulls in a built-in library file such as es2015. A directive placed after any statement is treated as an ordinary comment and ignored.

The types option is an allow-list for the @types packages that are auto-included as globals. Naming any package suppresses the automatic inclusion of all the others, so the test framework's global declarations disappear. typeRoots changes which folders that automatic inclusion scans.

maxNodeModuleJsDepth sets how many folder levels deep under node_modules TypeScript will load JavaScript files to infer types from. It defaults to 0 so dependency types come from declaration files, not from inferring over dependency source.

Treat the editor as feedback, a pre-commit hook as convenience, and a blocking CI job as the only real enforcement. Put the guarantee in CI, keep the other two as fast loops, and run the identical tsc --noEmit command everywhere.

isolatedDeclarations, added in TypeScript 5.5, makes the compiler reject exports whose declarations cannot be produced from a single file alone, forcing explicit annotations on the public surface. That guarantee lets other tools emit .d.ts files per file, in parallel, without whole-program inference.