Q: How do you safely work with JSON of unknown shape?

Type parsed JSON as **`unknown`**, then validate/narrow before use — either with manual type guards or a schema library (e.g. Zod) that both validates at runtime and infers the static type, avoiding unsafe `any`.

Question 1

How do you make values immutable in TypeScript?

Accepted Answer

Use the **`readonly`** modifier on properties or `ReadonlyArray`, and `Readonly` for whole objects. **`as const`** freezes a literal to its narrowest readonly type (great for tuples and config). These are compile-time guarantees, not runtime freezes.

Question 2

How do you do exhaustiveness checking?

Accepted Answer

In a `switch` over a discriminated union, add a `default` that assigns the value to a `never` variable: `const _exhaustive: never = value`. If you add a new variant and forget a case, the compiler errors — catching missed handling.

Question 3

What is the difference between interface and type?

Accepted Answer

Both describe object shapes. **`interface`** is extendable and supports declaration merging — ideal for public/object APIs. **`type`** is more flexible: it can alias unions, intersections, primitives, tuples, and mapped types. Use `interface` for objects you may extend, `type` for unions and computed types.

Question 4

What does `arethetypeswrong` (attw) detect and how do you fix false ESM/CJS packages?

Accepted Answer

Question 5

How do you debug type-resolution and ESM/CJS mismatches with `traceResolution` and `explain`?

Accepted Answer

Question 6

What is the difference between any and unknown?

Accepted Answer

**`any`** opts out of type checking entirely — anything goes. **`unknown`** is the type-safe counterpart: you can assign anything to it, but you must narrow it (via `typeof`, checks, or assertions) before using it. Prefer `unknown` to keep type safety.

Question 7

What is TypeScript and why use it over JavaScript?

Accepted Answer

**TypeScript** is a typed superset of JavaScript that compiles to plain JS. It adds static types, interfaces, generics, and enums — catching errors at compile time, improving editor autocomplete and refactoring, and making large codebases easier to maintain. All valid JS is valid TS.

Question 8

What are tuple types?

Accepted Answer

A **tuple** is a fixed-length array with known types per position: `[string, number]`. They support optional/rest elements and labels, and are used for things like coordinate pairs or React's `useState` return.

Question 9

What are `const` type parameters (`<const T>`) and why are they better than `as const`?

Accepted Answer

Question 10

How do you safely work with JSON of unknown shape?

Accepted Answer

Type parsed JSON as **`unknown`**, then validate/narrow before use — either with manual type guards or a schema library (e.g. Zod) that both validates at runtime and infers the static type, avoiding unsafe `any`.

TYPESCRIPTDECODED.

Transmission log

How do you make values immutable in TypeScript?

How do you do exhaustiveness checking?

What is the difference between interface and type?

What does `arethetypeswrong` (attw) detect and how do you fix false ESM/CJS packages?

How do you debug type-resolution and ESM/CJS mismatches with `traceResolution` and `explain`?

What is the difference between any and unknown?

What is TypeScript and why use it over JavaScript?

What are tuple types?

What are `const` type parameters (`<const T>`) and why are they better than `as const`?

How do you safely work with JSON of unknown shape?

What are literal types?

How does TypeScript handle null and undefined safely?

How does `satisfies` validate shape without widening literal types?

What are access modifiers in TypeScript classes?

How does `using` / `await using` with `Symbol.dispose` work in TypeScript 5.2+?

What is the definite assignment assertion (!)?

What is type narrowing and what are type guards?

What are generic constraints?

What are union and intersection types?

What do ReturnType and Parameters do?

What are generics and why are they useful?

What is ReadonlyArray and readonly tuple?

What are type assertions and when should you use them?

How does TypeScript 5.5 infer type predicates for `Array.filter` automatically?

What are abstract classes?

What is declaration merging?

What does the declare keyword do?

How does the 'in' operator narrow types?

What do Exclude, Extract, and NonNullable do?

What are utility types like Partial, Pick, and Omit?

What does the 'strict' flag in tsconfig enable?

How do you fix JSX and type-only import errors under `verbatimModuleSyntax`?

When should you use `moduleResolution: "bundler"` versus `"nodenext"`?

What is a discriminated union?

How do `noUncheckedIndexedAccess`, `exactOptionalPropertyTypes` and TS 5.6+ checks harden 2025 codebases?

What's new to type in TypeScript 5.5+ libs — `Array.fromAsync`, `Set` methods, `Iterator` helpers?

What is an index signature?

Can generics have default types?

What is structural typing?

How does `allowImportingTsExtensions` work with `moduleResolution: "bundler"` and `.ts` imports?

How do you get a union of an object's values as a type?

What is the Awaited utility type?

What do keyof and typeof do in TypeScript?

What does `verbatimModuleSyntax` enforce and why did it replace `importsNotUsedAsValues`?

What is the never type?

What are assertion functions (asserts)?

What is key remapping in mapped types?

What are enums and what are their trade-offs?

What are mapped types?

How would you build a DeepPartial type?

What are indexed access types?

How do you type and compose multiple disposables with `DisposableStack` and `AsyncDisposableStack`?

What are declaration files (.d.ts)?

How do you use `infer` to build deep `Awaited`, `ReturnType` and `Unwrap` utilities?

What does `NoInfer<T>` do and when should you block inference?

Why are conditional types distributive and how do you control it with `infer`?

How do TypeScript 5.0 Stage 3 decorators differ from legacy `experimentalDecorators`?

What are template literal types?

How do you author library types that pass `isolatedDeclarations` for `oxc` / `tsdown` builds?

What is module augmentation?

What are recursive types?

What does the infer keyword do?

What are function overloads?

What is a polymorphic 'this' type?

What are covariance and contravariance?

What is `isolatedDeclarations` and how does it enable single-file transpilation for declaration emit?

What are conditional types?

What does the satisfies operator do?

How do you choose between `NoInfer<T>`, `satisfies`, and `const` type params when designing APIs?

What are branded (nominal) types?

Difficulty mix

Tested topics

Decryption key