Typescript Error Fixes
TS2551: Property 'X' does not exist on type 'Y'. Did you mean 'Z'?
You're accessing a property that doesn't exist on the object's type — most often a typo, which TypeScript is helpfully guessing at with the "Did you mean" suggestion. Fix the spelling if it's a typo, or if the property genuinely should exist, check that you're importing/using the type you think you are (it may be a stale or differently-shaped version).
Error: tsgo: command not found — setting up the TypeScript 7 native preview compiler
TypeScript 7's Go-native compiler ships as a separate package (`@typescript/native-preview`) with its own `tsgo` binary, distinct from the classic `tsc` command that `typescript` provides — installing `typescript` alone doesn't give you `tsgo`. Install the native-preview package explicitly and invoke `tsgo` (or its npx form) instead of expecting `tsc` to switch automatically.
TS1484: 'X' is a type and must be imported using a type-only import when verbatimModuleSyntax is enabled
With `verbatimModuleSyntax` enabled, TypeScript no longer decides for you whether an import is type-only or a real runtime import — it emits imports exactly as written. If you import something that's only ever used as a type, you must write `import type { X }` explicitly, since a regular `import { X }` would try to import a non-existent runtime value.
Cannot find module or its type declarations after switching to "moduleResolution": "bundler"
`"moduleResolution": "bundler"` (recommended for projects using Vite, esbuild, or similar) resolves modules the way real bundlers do, which is stricter about a package's `exports` field than the older `node` resolution mode was. A package resolving fine under `node` mode can fail under `bundler` mode if its `exports` map doesn't declare a `types` condition, or omits a subpath you're importing.
TS2344: Type 'X' does not satisfy the constraint 'Y'
You're passing a type argument to a generic that doesn't satisfy the `extends` constraint the generic parameter declares. Check what the constraint actually requires (e.g. `T extends { id: string }`), and either pass a type that genuinely matches it, or loosen the constraint if it was written more narrowly than the function actually needs.
TS2790: The operand of a 'delete' operator must be optional
You're using `delete obj.prop` on a property that the object's type declares as required — TypeScript won't let you delete something that isn't allowed to be missing. Mark the property optional (`prop?: type`) if it's genuinely allowed to be absent, or set it to `undefined` instead of deleting it if the type must always have the key present.
TS2688 / global type errors after adding "types": [] to tsconfig.json
Setting `"types": []` (now common with TypeScript 6.0+'s stricter defaults) stops TypeScript from automatically including every @types/* package in node_modules as a global — which also silently drops packages like @types/node that your code actually relies on globally (like `process`, `Buffer`). List the global type packages you need explicitly in the `types` array.
Deprecation warning: 'baseUrl' is deprecated — what to use instead in TypeScript 6/7
TypeScript 6.0 deprecated the standalone `baseUrl` option (used for non-relative module resolution) as part of aligning with 7.0's module resolution rewrite. Use explicit `paths` mappings anchored relative to the tsconfig file instead, which is more explicit and doesn't rely on an implicit resolution root.
Error: Option 'target=es5' is not supported — removed in TypeScript 7.0
TypeScript 7.0's Go-native compiler dropped support for several legacy compile targets and module systems as part of the rewrite, including `target: "es5"`. Set `target` to a modern value like `es2020` or later — virtually every environment still receiving updates in 2026 supports it natively, so this rarely needs a polyfill-based workaround.
TypeScript 6.0 broke my build: strict mode is now on by default
TypeScript 6.0 (the bridge release ahead of the Go-native 7.0 compiler) turned on `strict: true` and several other options by default for new tsconfig.json files, and tightened behavior generally as part of aligning with 7.0. A project that relied on looser implicit defaults can suddenly surface dozens of previously-hidden errors. Explicitly set the options you actually want in tsconfig.json rather than relying on the previous implicit defaults.
TS2578: Unused '@ts-expect-error' directive
You added a `// @ts-expect-error` comment above a line expecting it to suppress a type error, but the line no longer actually produces one — usually because a related fix elsewhere in the code resolved it. Unlike `@ts-ignore`, `@ts-expect-error` is meant to fail loudly once it's no longer needed; just delete the now-unnecessary directive.
TS2532: Object is possibly 'undefined'
Similar to "Object is possibly 'null'", but for values TypeScript has inferred could be `undefined` — commonly from optional properties, optional function parameters, or array/Map lookups that don't guarantee an element exists. Narrow with an `if` check or optional chaining before accessing a property, rather than reaching for a non-null assertion by default.
TS2769: No overload matches this call
The function you're calling has multiple overload signatures, and your arguments don't match any of them exactly — the reported error can be long and confusing because TypeScript lists why each candidate overload failed. Read the LAST overload's specific mismatch first (it's usually the most general/relevant one), then check argument order, count, and types against it.
TS7053: Element implicitly has an 'any' type because expression can't be used to index type
You're indexing an object with a string/variable key whose exact literal value TypeScript can't verify matches one of the object type's known keys — commonly `obj[someVariable]` where `someVariable` is typed as plain `string`. Either add an index signature to the object's type, or narrow the key to a specific union of literal keys (`keyof typeof obj`).
TS2322: Type 'X' is not assignable to type 'Y'
You're assigning a value to a variable, property, or return position whose declared type doesn't structurally accept it. This is the assignment-context sibling of TS2345 (which fires on function arguments) — the fix is the same idea: either correct the value's shape, or widen the declared type if the narrower value should genuinely be allowed.
TS2345: Argument of type 'X' is not assignable to parameter of type 'Y'
You're passing a value into a function whose declared parameter type doesn't accept it — the shapes are incompatible, or a value could be undefined/null where the parameter doesn't allow it. Read the full error (TypeScript shows both types) to see exactly which property or branch doesn't line up, then either narrow/convert the argument or widen the parameter type.
TS2589: Type instantiation is excessively deep and possibly infinite
A recursive conditional or mapped type is nesting too deeply for TypeScript's instantiation depth limit — usually from processing a large union, a deeply recursive utility type, or inferring across many chained generic calls. Add an explicit base case to stop the recursion, or simplify the type so TypeScript doesn't have to expand it so many levels deep.