TypeScript Error Codes

Crack the code to your compiler problems with this ultimate list of common TypeScript errors. Each entry includes the faulty code and its fixed version, ensuring you can quickly resolve any issue and get back to coding.

Boost your productivity even further by installing the Pretty TypeScript Errors - VS Code Extension to see the error translations directly in your IDE.

All errors are categorized by the TypeScript team into the following ranges:

1xxx for syntactic errors
2xxx for semantic errors
4xxx for declaration emit errors
5xxx for compiler options errors
6xxx for command line errors
7xxx for type errors

The Ultimate Fix-it List:

TS1002
TS1005
TS1006
TS1015
TS1016
TS1029
TS1035
TS1036
TS1038
TS1039
TS1046
TS1054
TS1055
TS1056
TS1064
TS1066
TS1068
TS1070
TS1095
TS1099
TS1103
TS1107
TS1109
TS1117
TS1121
TS1127
TS1128
TS1149
TS1155
TS1160
TS6133
TS1163
TS1175
TS1183
TS1192
TS1196
TS1202
TS1208
TS1218
TS1219
TS1225
TS1228
TS1232
TS1240
TS1241
TS1243
TS1244
TS1247
TS1248
TS1254
TS1259
TS1274
TS1280
TS1308
TS1309
TS1323
TS1337
TS1341
TS1345
TS1355
TS1357
TS1361
TS1363
TS1368
TS1371
TS1375
TS1378
TS1385
TS1389
TS1431
TS1432
TS1434
TS1450
TS1470
TS1471
TS1479
TS1484
TS2300
TS2304
TS2305
TS2306
TS2307
TS2314
TS2315
TS2318
TS2322
TS2335
TS2339
TS2341
TS2344
TS2345
TS2348
TS2349
TS2350
TS2351
TS2352
TS2353
TS2355
TS2361
TS2362
TS2364
TS2365
TS2366
TS2367
TS2368
TS2369
TS2370
TS2371
TS2372
TS2377
TS2378
TS2383
TS2389
TS2390
TS2391
TS2393
TS2394
TS2395
TS2397
TS2403
TS2411
TS2415
TS2416
TS2420
TS2425
TS2428
TS2430
TS2440
TS2445
TS2448
TS2451
TS2454
TS2456
TS2459
TS2475
TS2476
TS2488
TS2491
TS2497
TS2498
TS2503
TS2504
TS2507
TS2511
TS2512
TS2515
TS2528
TS2531
TS2532
TS2533
TS2536
TS2537
TS2538
TS2539
TS2540
TS2550
TS2551
TS2552
TS2554
TS2556
TS2558
TS2559
TS2561
TS2564
TS2567
TS2571
TS2574
TS2577
TS2580
TS2582
TS2583
TS2584
TS2588
TS2589
TS2595
TS2604
TS2611
TS2612
TS2613
TS2614
TS2616
TS2617
TS2632
TS2636
TS2637
TS2638
TS2652
TS2654
TS2656
TS2661
TS2663
TS2664
TS2665
TS2668
TS2669
TS2674
TS2677
TS2678
TS2680
TS2683
TS2684
TS2686
TS2687
TS2688
TS2689
TS2691
TS2693
TS2694
TS2695
TS2705
TS2706
TS2707
TS2709
TS2713
TS2715
TS2717
TS2720
TS2722
TS2724
TS2730
TS2732
TS2739
TS2740
TS2741
TS2742
TS2749
TS2769
TS2774
TS2779
TS2786
TS2790
TS2792
TS2794
TS2802
TS2813
TS2814
TS2820
TS2821
TS2823
TS2834
TS2835
TS2845
TS2855
TS4010
TS4020
TS4023
TS4025
TS4031
TS4055
TS4060
TS4063
TS4075
TS4081
TS4104
TS4111
TS4112
TS4113
TS4114
TS5023
TS5024
TS5025
TS5042
TS5054
TS5055
TS5058
TS5069
TS5070
TS5083
TS5087
TS5093
TS5095
TS5097
TS5101
TS5110
TS6053
TS6059
TS6133
TS6138
TS6192
TS6196
TS6198
TS6234
TS6385
TS6387
TS6504
TS7005
TS7006
TS7008
TS7009
TS7010
TS7016
TS7017
TS7022
TS7023
TS7026
TS7027
TS7029
TS7030
TS7031
TS7034
TS7038
TS7041
TS7044
TS7053
TS8020
TS17000
TS17004
TS17009
TS17019
TS18003
TS18004
TS18016
TS18026
TS18028
TS18046
TS18047
TS18048
TS18049
TS18052
TS71002
TS80001
TS80005

TS1002

Unterminated string literal.

Broken Code ❌

const text = 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr

Fixed Code ✔️

You have to close the string literal with an ending ':

const text = 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr';

If you want to support multiline text, then you would have to use string concatenation:

const text =
  'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, ' +
  'sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.';

Another solution would be using a template literal:

const text = `Lorem ipsum dolor sit amet, consetetur sadipscing elitr, 
  sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.`;

TS1005

'=' expected.

Broken Code ❌

type Person {
  age: number;
  name: string;
}

Fixed Code ✔️

You need to assign your type declaration using the = character:

type Person = {
  age: number;
  name: string;
};

Alternatively, you can declare an interface:

interface Person {
  age: number;
  name: string;
}

';' expected.

Broken Code ❌

export function getNumbers(names: string[]) {
  return names.map(name => {[name]: parseInt(name)});
}

Fixed Code ✔️

When using an arrow function expression, you can implicitly return values by wrapping the object literal in parentheses:

export function getNumbers(names: string[]) {
  return names.map((name) => ({ [name]: parseInt(name) }));
}

TS1006

A file cannot have a reference to itself.

Broken Code ❌

index.d.ts

/// <reference path='index.d.ts' />

Fixed Code ✔️

You cannot reference a file to itself (causes recursive loop). To fix the problem you have to update the reference path to point to another declaration file:

index.d.ts

/// <reference path='some-other-file.d.ts' />

TS1015

Parameter cannot have question mark and initializer.

Broken Code ❌

export function getName(firstName: string, lastName?: string = 'Doe'): string {
  return `${firstName} ${lastName}`;
}

Fixed Code ✔️

export function getName(firstName: string, lastName: string = 'Doe'): string {
  return `${firstName} ${lastName}`;
}

TS1016

A required parameter cannot follow an optional parameter.

Broken Code ❌

function createUser(firstName: string, lastName: string, middleName?: string, age: number) {
  // ...
}

Fixed Code ✔️

The easiest way to fix the error is to make age optional as well:

function createUser(firstName: string, lastName: string, middleName?: string, age?: number) {
  // ...
}

Alternatively, you can flip the order of middleName and age. Be aware that this breaks the contract (signature) of the function and is considered a "breaking change":

function createUser(firstName: string, lastName: string, age: number, middleName?: string) {
  // ...
}

You could also make middleName non-optional:

function createUser(firstName: string, lastName: string, middleName: string, age?: number) {
  // ...
}

Yet another solution would be to assign a default value to middleName so it won't be optional by default. This allows age to be optional then:

function createUser(firstName: string, lastName: string, middleName: string = '', age?: number) {
  // ...
}

TS1029

'public' modifier must precede 'abstract' modifier.

Broken Code ❌

abstract class Animal {
  public abstract makeNoise(): string;
}

Fixed Code ✔️

They keywords public, private, and protected define the access to a class member. Access modifiers have to be defined first in TypeScript.

Solution 1:

abstract class Animal {
  public abstract makeNoise(): string;
}

Solution 2:

The visibility is public by default, so you don't have to explicitly declare it:

abstract class Animal {
  abstract makeNoise(): string;
}

Video Tutorial

TS1035

Only ambient modules can use quoted names.

Broken Code ❌

module 'global' {
  namespace globalThis {
    var signin: () => string[];
  }
}
 
this.signin();

Fixed Code ✔️

To turn a module into an ambient module, you have to prefix it with the declare keyword:

declare module 'global' {
  namespace globalThis {
    var signin: () => string[];
  }
}
 
this.signin();

TS1036

Statements are not allowed in ambient contexts.

Broken Code ❌

import { APIClient } from '../../APIClient';
 
declare global {
  client: APIClient;
}

Fixed Code ✔️

With declare global an ambient context is created. TypeScript does not allow statements in such ambient context declaration which is why we have to change the statement into a declaration:

declare global {
  function client(): APIClient;
}

If you don't want client to be a function, you have to use the var` keyword:

declare global {
  var client: APIClient;
}

TS1038

A 'declare' modifier cannot be used in an already ambient context.

Broken Code ❌

declare global {
  declare var REST_URL: string;
}

Fixed Code ✔️

declare global {
  var REST_URL: string;
}

TS1039

Initializers are not allowed in ambient contexts.

Broken Code ❌

index.d.ts

declare module hexo {
  var config = {};
}

Fixed Code ✔️

Within a declaration file (ambient context), you should define types instead of implementing code. Consequently, you'll need to replace the initialization with a type annotation:

index.d.ts

declare module hexo {
  var config: {};
}

TS1046

Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier.

Broken Code ❌

index.d.ts

const MAGIC_NUMBER = 1337;

Fixed Code ✔️

If you want to export a constant from a definition file (d.ts), then you have to use the export modifier:

index.d.ts

export const MAGIC_NUMBER = 1337;

TS1054

TS1054: A get accessor cannot have parameters.

Broken Code ❌

get isLong(input: string) {
  return this.config.orderPosition === ExchangeOrderPosition.LONG;
}

Solution:

To fix this issue, you need to convert the get accessor to a regular method since TypeScript does not allow parameters for getters. This change allows the method to accept arguments as required.

Fixed Code ✔️

isLong(input: string): boolean {
  return this.config.orderPosition === ExchangeOrderPosition.LONG;
}

TS1055

Type 'AxiosPromise' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.

Broken Code ❌

export const sendRequestWithCookie = async (
  client: HttpClient,
  config: AxiosRequestConfig,
  engine: CRUDEngine
): AxiosPromise => {
  const cookie: Cookie = await loadExistingCookie(engine);
 
  if (!cookie.isExpired) {
    config.headers = config.headers || {};
    config.headers['Cookie'] = `zuid=${cookie.zuid}`;
    config.withCredentials = true;
  }
 
  return client._sendRequest(config);
};

Fixed Code ✔️

export const sendRequestWithCookie = (
  client: HttpClient,
  config: AxiosRequestConfig,
  engine: CRUDEngine
): AxiosPromise => {
  return loadExistingCookie(engine).then((cookie: Cookie) => {
    if (!cookie.isExpired) {
      config.headers = config.headers || {};
      config.headers['Cookie'] = `zuid=${cookie.zuid}`;
      config.withCredentials = true;
    }
 
    return client._sendRequest(config);
  });
};

TS1056

Accessors are only available when targeting ECMAScript 5 and higher.

Broken Code ❌

User.ts

class User {
  constructor(
    private firstName: string,
    private lastName: string
  ) {}
 
  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  }
}

tsconfig.json

{
  "compilerOptions": {
    "target": "es3"
  }
}

Fixed Code ✔️

Set the "target" property in your "tsconfig.json" file to "es5" or higher:

tsconfig.json

{
  "compilerOptions": {
    "target": "es5"
  }
}

TS1064

The return type of an async function or method must be the global Promise type. Did you mean to write 'Promise '?

Broken Code ❌

async function myFunction(): string {
  return 'test';
}

Fixed Code ✔️

If your function is asynchronous, your return value must be wrapped with Promise<...>:

async function myFunction(): Promise<string> {
  return 'test';
}

TS1066

In ambient enum declarations member initializer must be constant expression.

Broken Code ❌

enum PreKeyAuth {
  INVALID = 'Invalid',
  UNKNOWN = 'Unknown',
  VALID = 'Valid',
}

Fixed Code ✔️

Try to replace your enum declaration with a type:

type PreKeyAuth = 'Invalid' | 'Unknown' | 'Valid';

TS1068

Unexpected token. A constructor, method, accessor, or property was expected.

Broken Code ❌

class User {
  constructor(private firstName: string, private lastName: string) {
  }
 
  function getName() {
    return `${this.firstName} ${this.lastName}`;
  }
}

Fixed Code ✔️

Functions that are part of a class are being called "method". The method of a class is defined without the function keyword:

class User {
  constructor(
    private firstName: string,
    private lastName: string
  ) {}
 
  getName() {
    return `${this.firstName} ${this.lastName}`;
  }
}

TS1070

'private' modifier cannot appear on a type member.

Broken Code ❌

interface Animal {
  private name: string;
}

Fixed Code ✔️

Interfaces are structures that define the public contract. This prohibits you from using private modifiers. Only public and protected can be used. To solve the problem, the private keyword must be removed from the name property of the Animal interface:

interface Animal {
  name: string;
}

Video Tutorial

TS1095

A 'set' accessor cannot have a return type annotation.

Broken Code ❌

export class Person {
  private myName: string = 'unknown';
 
  get name(): string {
    return this.myName;
  }
 
  set name(newName: string): void {
    this.myName = newName;
  }
}

Fixed Code ✔️

You have to remove the return type from the "set" accessor:

export class Person {
  private myName: string = 'unknown';
 
  get name(): string {
    return this.myName;
  }
 
  set name(newName: string) {
    this.myName = newName;
  }
}

TS1099

Type argument list cannot be empty.

Broken Code ❌

const result = await response.json<>();

This error occurs because TypeScript does not allow empty type argument lists (<>).

Fixed Code ✔️

The method response.json() does not expect generic parameters to be provided. You don't need to provide any generic type parameters. Simply remove the empty type argument list (<>) from the method call:

const result = await response.json();

If you want to strongly type the result, you can cast it using as:

interface MyResponse {
  data: string;
}
 
const result = (await response.json()) as MyResponse;
console.log(result.data);

TS1103

'for await' loops are only allowed within async functions and at the top levels of modules.

Broken Code ❌

import fs from 'node:fs';
import readline from 'node:readline';
 
const inputStream = fs.createReadStream('file.csv');
 
function printLine(file: string): Promise<void> {
  const rl = readline.createInterface({
    input: inputStream,
    crlfDelay: Infinity,
  });
 
  for await (const line of rl) {
    console.log(line);
  }
}

Fixed Code ✔️

You have to mark your function with the async keyword:

import fs from 'node:fs';
import readline from 'node:readline';
 
const inputStream = fs.createReadStream('file.csv');
 
async function printLine(file: string): Promise<void> {
  const rl = readline.createInterface({
    input: inputStream,
    crlfDelay: Infinity,
  });
 
  for await (const line of rl) {
    console.log(line);
  }
}

TS1107

Jump target cannot cross function boundary.

Broken Code ❌

export async function fixFatalLooseObject(git: SimpleGit) {
  // ...
  if (!confirmedDeletion) {
    break;
  }
}

Solution:

Replace break with return to exit the function when the condition is met:

Fixed Code ✔️

export async function fixFatalLooseObject(git: SimpleGit) {
  // ...
  if (!confirmedDeletion) {
    return;
  }
}

TS1109

Expression expected.

Broken Code ❌

const lastName = throw new Error('Missing last name');

Fixed Code ✔️

Any snippet of code that evaluates to a value is an expression. Any snippet of code that performs an action is a statement. We need a statement to throw an error inside:

const lastName = undefined;
if (!lastName) {
  throw new Error('Missing last name');
}

TS1117

An object literal cannot have multiple properties with the same name in strict mode.

Broken Code ❌

const objectLiteral = {
  name: 'Benny',
  name: 'Sofia',
};

Fixed Code ✔️

We can only have one value per property:

const objectLiteral = {
  name: 'Benny',
};

TS1121

Octal literals are not allowed. Use the syntax '0o0'.

Broken Code ❌

new Money(200,00)

Solution:

Remove the extra zero to prevent the JavaScript interpreter from treating it as an octal literal.

Fixed Code ✔️

new Money(200, 0);

TS1127

Invalid character.

Broken Code ❌

# My comment

Fixed Code ✔️

Unlike in Python, inline comments cannot begin with a single hash sign (#) in TypeScript. You must use 2 slashes:

// My comment

TS1128

Declaration or statement expected.

Broken Code ❌

Fixed Code ✔️

A declaration specifies the data and a statement specifies some action with that data:

// Declaration
let MY_NUMBER = 1;
// Statement
MY_NUMBER = MY_NUMBER + 1;

TS1149

File name differs from already included file name only in casing.

Broken Code ❌

This error occurs when you import the same file in two different files using two different casing styles (ex. camelCase and UpperCamelCase):

File A:

import { BaseTestPage } from './baseTestPage';

File B:

import { BaseTestPage } from './BaseTestPage';

Fixed Code ✔️

The error can be fixed by using the same casing style:

File A:

import { BaseTestPage } from './BaseTestPage';

File B:

import { BaseTestPage } from './BaseTestPage';

Alternatively, you can set forceConsistentCasingInFileNames to false in your "tsconfig.json" file:

tsconfig.json

{
  "compilerOptions": {
    "forceConsistentCasingInFileNames": false
  }
}

TS1155

'const' declarations must be initialized.

Broken Code ❌

const name: string;

Fixed Code ✔️

const name: string = 'Benny';

Alternatively you can define a block-scoped local variable:

let name: string;

TS1160

Unterminated template literal.

Broken Code ❌

const text = `Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
  sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.

Fixed Code ✔️

This error is similar to TS1002 but refers to the ending of a template literal. To fix it, we have to close the template literal with an ending `:

const text = `Lorem ipsum dolor sit amet, consetetur sadipscing elitr, 
  sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.`;

TS6133

Unterminated regular expression literal.

Broken Code ❌

filter: path => /^\/blog\/g.test(path)

Solution:

Correct the regular expression by removing the unnecessary escape before the 'g' flag.

Fixed Code ✔️

filter: (path) => /^\/blog/g.test(path);

TS1163

A 'yield' expression is only allowed in a generator body.

Broken Code ❌

function* iterateAlphabet() {
  const alphabet = Array.from({ length: 26 }, (_value, index) => String.fromCharCode(index + 65));
 
  for (const char of alphabet) {
    yield char;
  }
}
 
const alphabetGenerator = iterateAlphabet();
 
for (const char of alphabetGenerator) {
  console.log(yield char);
}

Fixed Code ✔️

You have to remove the yield keyword from the for-of loop:

function* iterateAlphabet() {
  const alphabet = Array.from({ length: 26 }, (_value, index) => String.fromCharCode(index + 65));
 
  for (const char of alphabet) {
    yield char;
  }
}
 
const alphabetGenerator = iterateAlphabet();
 
for (const char of alphabetGenerator) {
  console.log(char);
}

Broken Code ❌

async fetchData(address: string, ticker: string) {
  let cursor: number | undefined = 0;
  while (cursor) {
    const query = new URLSearchParams({
      cursor: `${cursor}`,
      ticker,
      limit: '50'
    })
    const response = await fetch(url);
    const payload = await response.json();
    const parsed = ResponseSchema.parse(payload);
    for (const result of parsed.results) {
      yield result;
    }
    parsed.next_url ? (url = new URL(parsed.next_url)) : (url = undefined);
  }
}

Solution:

Add the * symbol to define the function as a generator-async function, allowing yield within its body.

Fixed Code ✔️

async *fetchData(address: string, ticker: string) {
  let cursor: number | undefined = 0;
  while (cursor) {
    const query = new URLSearchParams({
      cursor: `${cursor}`,
      ticker,
      limit: '50'
    })
    const response = await fetch(url);
    const payload = await response.json();
    const parsed = ResponseSchema.parse(payload);
    for (const result of parsed.results) {
      yield result;
    }
    parsed.next_url ? (url = new URL(parsed.next_url)) : (url = undefined);
  }
}

TS1175

'implements' clause already seen.

Broken Code ❌

interface Calculator {
  (x: number, y: number): number;
}
 
interface ExtendedCalculator extends Calculator {
  squareRoot(x: number): number;
}
 
class AdvancedCalculator implements ExtendedCalculator implements Calculator {
  // class implementation
}

Solution:

Remove the redundant implements Calculator since ExtendedCalculator already extends Calculator.

Fixed Code ✔️

interface Calculator {
  (x: number, y: number): number;
}
 
interface ExtendedCalculator extends Calculator {
  squareRoot(x: number): number;
}
 
class AdvancedCalculator implements ExtendedCalculator {
  // class implementation
}

TS1183

An implementation cannot be declared in ambient contexts.

Broken Code ❌

index.d.ts

export function logSomething(error: unknown): void {
  console.log('something');
}

Fixed Code ✔️

You cannot write a function implementation inside a declaration file (*.d.ts). You can only declare its signature:

index.d.ts

export function logSomething(error: unknown): void;

Alternatively, you can write your function implementation inside a source code file (*.ts).

TS1192

Module 'json5' has no default export.

Broken Code ❌

import json5 from 'json5';

Fixed Code ✔️

When you are importing a module with built-in TypeScript declarations and TypeScript tells you that this module does not have a default export, then you can solve this problem by adding "allowSyntheticDefaultImports" to your "tsconfig.json" file and setting it to true:

tsconfig.json

{
  "compilerOptions": {
    "allowSyntheticDefaultImports": true
  }
}

Module '.../logdown' has no default export.

Broken Code ❌

declare class Logdown {
  // ...
}
 
export = Logdown;

Fixed Code ✔️

declare class Logdown {
  // ...
}
 
export default Logdown;

'export *' does not re-export a default.

Broken Code ❌

export * from './parseUrls';
export * from './runWhenReady';

You have to re-export a default (in this case coming from runWhenReady.ts):

Fixed Code ✔️

export * from './parseUrls';
export * from './runWhenReady';
export { default as default } from './runWhenReady';

TS1196

Catch clause variable type annotation must be 'any' or 'unknown' if specified.

Broken Code ❌

type MyError = {
  code: number;
};
 
try {
  // ...
} catch (error: MyError) {
  console.log(error.code);
}

Fixed Code ✔️

Errors in catch clauses can only be typed with any or unknown. If you need a more precise error typing, you can use a type guard as follows:

// Type Guard
function isMyError(error: any): error is MyError {
  return typeof error.code === 'number';
}
 
type MyError = {
  code: number;
};
 
try {
  // ...
} catch (error: unknown) {
  if (isMyError(error)) {
    console.log(error.code);
  }
}

Video Tutorial

TS1202

Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead.

Broken Code ❌

import sinon = require('sinon');

Fixed Code ✔️

import * as sinon from 'sinon';

TS1208

'index.ts' cannot be compiled under '--isolatedModules' because it is considered a global script file. Add an import, export, or an empty 'export {}' statement to make it a module.

Broken Code ❌

tsconfig.json

{
  "compilerOptions": {
    "isolatedModules": true
  }
}

index.ts

require(`dotenv-defaults`).config({
  path: '.env',
});

Fixed Code ✔️

To solve the issue you can turn off "isolatedModules" in your "tsconfig.json". If you want to keep going with isolated modules, then you have to add an import or export to your code:

index.ts

require(`dotenv-defaults`).config({
  path: '.env',
});
 
export default {};

TS1218

Export assignment is not supported when '--module' flag is 'system'.

Broken Code ❌

class LRUCache {
  // ...
}
 
export = LRUCache;

Fixed Code ✔️

export class LRUCache {
  // ...
}

TS1219

Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option in your 'tsconfig' or 'jsconfig' to remove this warning.

Broken Code ❌

import { Injectable } from '@nestjs/common';
 
@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

Fixed Code ✔️

Simply set "experimentalDecorators" to true in your "tsconfig.json" file. As long as decorators are experimental you will also have to install the reflect-metadata package to shim the upcoming Metadata Reflection API for ECMAScript. For proper functionality the "emitDecoratorMetadata" option should also be set to true.

TS1225

Cannot find parameter 'error'.

Broken Code ❌

const isError = (): input is Error => {
  return input instanceof Error;
};

Fixed Code ✔️

A type predicate needs a parameter to validate:

const isError = (input: unknown): input is Error => {
  return input instanceof Error;
};

TS1228

A type predicate is only allowed in return type position for functions and methods.

Broken Code ❌

function hasErrorCode(error: any) error is {code: string} {
  return typeof (error && error.code) === 'string'
}

Fixed Code ✔️

You have to separate the argument list from the return type definition by a ::

function hasErrorCode(error: any): error is { code: string } {
  return typeof (error && error.code) === 'string';
}

TS1232

An import declaration can only be used at the top level of a namespace or module.

Broken Code ❌

export function dumpPayload() {
  const payload = {};
  import { writeFileSync } from 'fs';
  writeFileSync(`dump-${Date.now()}.json`, JSON.stringify(payload));
}

Fixed Code ✔️

import { writeFileSync } from 'fs';
 
export function dumpPayload() {
  const payload = {};
  writeFileSync(`dump-${Date.now()}.json`, JSON.stringify(payload));
}

TS1240

Unable to resolve signature of property decorator when called as an expression. The runtime will invoke the decorator with 2 arguments, but the decorator expects 3.

Broken Code ❌

function CatchError() {
  return function (target: any, _propertyKey: string | symbol, _descriptor: PropertyDescriptor) {
    function replacementMethod(this: any, ...args: any[]) {
      try {
        return target.apply(this, ...args);
      } catch (error) {
        console.error('Yikes', error);
      }
    }
 
    return replacementMethod();
  };
}
 
class Example {
  @CatchError()
  function doSomething() {
    throw new Error('I am failing!');
  }
}
 
const example = new Example();
example.doSomething();

The problem is that the CatchError decorator is defined as a method decorator but is being used as a property decorator.

Fixed Code ✔️

To fix this issue, turn the method into a property by removing the function keyword:

function CatchError() {
  return function (target: any, _propertyKey: string | symbol, _descriptor: PropertyDescriptor) {
    function replacementMethod(this: any, ...args: any[]) {
      try {
        return target.apply(this, ...args);
      } catch (error) {
        console.error('Yikes', error);
      }
    }
 
    return replacementMethod();
  };
}
 
class Example {
  @CatchError()
  doSomething() {
    throw new Error('I am failing!');
  }
}
 
const example = new Example();
example.doSomething();

TS1241

Unable to resolve signature of method decorator when called as an expression.

Broken Code ❌

function CatchError(logMessage: string) {
  return function (_target: any, descriptor: PropertyDescriptor) {
    // Save a reference to the original method
    const originalMethod = descriptor.value;
 
    // Replace the method with a new function
    descriptor.value = function (...args: any[]) {
      try {
        return originalMethod.apply(this, args);
      } catch (error) {
        console.error(logMessage, error);
      }
    };
  };
}
 
class Example {
  @CatchError('Error occurred in doSomething')
  doSomething() {
    throw new Error('I am failing!');
  }
}
 
const example = new Example();
example.doSomething();

This code throws an error because the decorator CatchError is missing the correct signature for the PropertyDescriptor.

Fixed Code ✔️

To fix this issue, update the signature for the decorator to include the _propertyKey parameter:

function CatchError(logMessage: string) {
  return function (_target: any, _propertyKey: string | symbol, descriptor: PropertyDescriptor) {
    // Save a reference to the original method
    const originalMethod = descriptor.value;
 
    // Replace the method with a new function
    descriptor.value = function (...args: any[]) {
      try {
        return originalMethod.apply(this, args);
      } catch (error) {
        console.error(logMessage, error);
      }
    };
  };
}
 
class Example {
  @CatchError('Error occurred in doSomething')
  doSomething() {
    throw new Error('I am failing!');
  }
}
 
const example = new Example();
example.doSomething();

With this adjustment, the CatchError decorator now properly resolves the method signature, allowing you to catch and log errors as intended.

TS1243

'static' modifier cannot be used with 'abstract' modifier.

Broken Code ❌

abstract class CustomNumber {
  static abstract getNumber(): number;
}

You cannot define a function that is static and abstract. You have to keep it static:

Fixed Code ✔️

abstract class CustomNumber {
  static getNumber(): number {
    return 1337;
  }
}

'async' modifier cannot be used with 'abstract' modifier.

Broken Code ❌

abstract async goto(): Promise<void>;

Fixed Code ✔️

abstract goto(): Promise<void>;

TS1244

Abstract methods can only appear within an abstract class.

Broken Code ❌

class Animal {
  abstract makeNoise(): string;
}

Fixed Code ✔️

abstract class Animal {
  abstract makeNoise(): string;
}

TS1247

A type literal property cannot have an initializer.

Broken Code ❌

export function getName({name}: { name: string = 'Unknown' }) {
  return name;
}
 
console.log(getName(undefined));

Fixed Code ✔️

The getName function expects an object literal. However, in TypeScript, object literals are not allowed to have initializing functions or values. To work around this limitation and make use of an initializer, we can convert the object literal into a collective type:

export function getName(name: string = 'Unknown') {
  return name;
}
 
console.log(getName(undefined));

TS1248

A class member cannot have the 'const' keyword.

Broken Code ❌

class MyBaseClass {}
 
export class MyExtendedClass extends MyBaseClass {
  myConstant = '';
}

Fixed Code ✔️

When inheriting from a base class, you have to use modifiers like readonly if you want your class members to become constant:

class MyBaseClass {}
 
export class MyExtendedClass extends MyBaseClass {
  readonly myConstant = '';
}

TS1254

A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.

Broken Code ❌

index.d.ts

declare module megalibrary {
  const MEGA_NUMBER = {};
}

Fixed Code ✔️

index.d.ts

declare module megalibrary {
  const MEGA_NUMBER = 1337;
}

TS1259

Module can only be default-imported using the 'esModuleInterop' flag

Broken Code ❌

main.ts

import api from 'api';

tsconfig.json

{
  "compilerOptions": {
    "lib": ["dom", "es6"],
    "module": "commonjs",
    "moduleResolution": "node",
    "outDir": "dist",
    "rootDir": "src",
    "target": "es6"
  }
}

Fixed Code ✔️

tsconfig.json

{
  "compilerOptions": {
    "esModuleInterop": true,
    "lib": ["dom", "es6"],
    "module": "commonjs",
    "moduleResolution": "node",
    "outDir": "dist",
    "rootDir": "src",
    "target": "es6"
  }
}

Note: You can enable the 'esModuleInterop' flag also via the CLI:

tsc main.ts --esModuleInterop

TS1274

'in' modifier can only appear on a type parameter of a class, interface or type alias.

Broken Code ❌

function getArrayElement<in out T>(array: T[], index: number): T {
  return array[index];
}

Solution:

Remove the in and out modifiers from the function type parameter.

Fixed Code ✔️

function getArrayElement<T>(array: T[], index: number): T {
  return array[index];
}

TS1280

Namespaces are not allowed in global script files when verbatimModuleSyntax is enabled. If this file is not intended to be a global script, set moduleDetection to force or add an empty export {} statement.

Broken Code ❌

module global {
  namespace globalThis {
    var signin: () => string[];
  }
}
 
this.signin();

Fixed Code ✔️

Use a quotes around the name global and turn it into an ambient module by using the declare module syntax:

declare module 'global' {
  namespace globalThis {
    var signin: () => string[];
  }
}
 
this.signin();

TS1308

'await' expressions are only allowed within async functions and at the top levels of modules.ts.

Broken Code ❌

React.useEffect(() => {
  const myPromise = Promise.resolve;
  await myPromise();
  console.log('Promise is resolved.');
}, []);

Fixed Code ✔️

You cannot use an await expression in an useEffect hook, but you can use legacy Promise calls:

React.useEffect(() => {
  const myPromise = Promise.resolve;
  myPromise().then(() => {
    console.log('Promise is resolved.');
  });
}, []);

Alternatively, you can use an IIFE (Immediately-invoked Function Expression) in your useEffect hook:

React.useEffect(() => {
  (async () => {
    await Promise.resolve();
  })();
}, []);

TS1309

TS1309: The current file is a CommonJS module and cannot use 'await' at the top level.

Broken Code ❌

const response = await youtube.playlistItems.list({
  part: ['snippet'],
  playlistId,
});

Solution:

This error occurs because top-level await is only supported in ECMAScript modules, not in CommonJS modules which are the default module system in Node.js unless specified otherwise.

To use top-level await, you need to configure your project to use ECMAScript modules by adding "type": "module" to your package.json. This tells Node.js to treat all code files as ECMAScript modules.

Fixed Code ✔️

{
  "name": "your-package-name",
  "version": "1.0.0",
  "type": "module"
}

Another Solution:

To work around the restriction of not using await at the top level in a CommonJS module, you can also encapsulate your asynchronous operations within an Immediately Invoked Function Expression (IIFE) that is async:

(async () => {
  const response = await youtube.playlistItems.list({
    part: ['snippet'],
    playlistId,
  });
 
  console.log(response.data.items);
})();

TS1323

Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', or 'nodenext'.

Broken Code ❌

main.ts

import('trading-signals').then((tradingSignals) => {
  const { Big, SMA } = tradingSignals;
 
  const sma = new SMA(3);
});

tsconfig.json

{
  "compilerOptions": {
    "module": "es2015"
  }
}

Fixed Code ✔️

Dynamic imports are expressions that enable the loading of an ECMAScript module (ESM) into CommonJS modules (CJS).

The import() expression also allow modules to be loaded conditionally on demand. This feature was introduced with the ECMAScript® 2020 Language Specification.

If your project uses an older module system, remember to update the module setting in your TypeScript compiler settings.

main.ts

import('trading-signals').then((tradingSignals) => {
  const { Big, SMA } = tradingSignals;
 
  const sma = new SMA(3);
});

tsconfig.json

{
  "compilerOptions": {
    "module": "node16"
  }
}

TS1337

An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead.

Broken Code ❌

export interface StreetMap {
  [city: 'New York']: ['Broadway', 'Park Avenue'];
}

Fixed Code ✔️

export type StreetMap = {
  'New York': ['Broadway', 'Park Avenue'];
};

Alternative:

export interface StreetMap {
  [city: string]: ['Broadway', 'Park Avenue'];
}

An index signature parameter type cannot be a union type. Consider using a mapped object type instead.

Broken Code ❌

interface CustomError {
  [key: string | number]: string | number;
}
 
const error: CustomError = {
  401: 'Unauthorized',
};

Fixed Code ✔️

Solution with mapped object type:

type CustomError = {
  [key in number | string]: string | number;
};
 
const error: CustomError = {
  401: 'Unauthorized',
};

Alternative:

interface ErrorNumber {
  [key: number]: string | number;
}
 
interface ErrorString {
  [key: string]: string | number;
}
 
const error: ErrorNumber | ErrorString = {
  401: 'Unauthorized',
};

TS1341

Class constructor may not be an accessor.

Broken Code ❌

class SomeClass {
  get constructor() {
    // ...
  }
  set constructor(value) {
    // ...
  }
}

Fixed Code ✔️

You can't name accessors as constructor:

class SomeClass {
  get builder() {
    // ...
  }
  set builder(value) {
    // ...
  }
}

TS1345

An expression of type 'void' cannot be tested for truthiness.

Broken Code ❌

type PositiveNumber = number & { __brand: 'PositiveNumber' };
 
function divide(a: number, b: PositiveNumber) {
  return a / b;
}
 
function assertPositiveNumber(x: unknown): asserts x is PositiveNumber {
  if (typeof x === 'number' && x < 0) {
    throw new Error('Input is a negative number');
  }
}
 
if (assertPositiveNumber(10)) {
  divide(100, 10);
}

Solution:

This error occurs because the assertPositiveNumber function is an assertion function and does not return a value (its return type is void). You should call it directly to perform the assertion and then proceed with the divide function if no error is thrown.

Fixed Code ✔️

type PositiveNumber = number & { __brand: 'PositiveNumber' };
 
function divide(a: number, b: PositiveNumber) {
  return a / b;
}
 
function assertPositiveNumber(x: unknown): asserts x is PositiveNumber {
  if (typeof x !== 'number' || x <= 0) {
    throw new Error('Input is not a positive number');
  }
}
 
const num = 10;
assertPositiveNumber(num);
divide(100, num);

TS1355

A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals.

Broken Code ❌

const result = (Math.random() < 0.5 ? 0 : 1) as const;

Fixed Code ✔️

You cannot apply a const assertion to the result of a ternary operator. It is necessary to restrict the usage of const assertions to the individual literal expressions:

const result = Math.random() < 0.5 ? (0 as const) : (1 as const);

TS1357

An enum member name must be followed by a ',', '=', or '}'.

Broken Code ❌

enum GameAction {
  RUN : 'RUN'
}

Fixed Code ✔️

enum GameAction {
  RUN = 'RUN',
}

TS1361

'Range' cannot be used as a value because it was imported using 'import type'.

Broken Code ❌

import type { Range, TextEditor } from 'vscode';
 
export class Ranger {
  static getFullRange(editor: TextEditor): Range {
    const lastLine = textEditor.document.lineAt(textEditor.document.lineCount - 1);
    const firstLine = textEditor.document.lineAt(0);
    return new Range(firstLine.range.start, lastLine.range.end);
  }
}

Fixed Code ✔️

The type Range is being used to declare the return type of static function Ranger.getFullRange but later on it is also being used to create an instance using new Range. When you want to use a type to construct instances (or do anything else beyond declaring types), then you have to use the import statement instead of import type:

import type { TextEditor } from 'vscode';
import { Range } from 'vscode';
 
export class Ranger {
  static getFullRange(editor: TextEditor): Range {
    const lastLine = textEditor.document.lineAt(textEditor.document.lineCount - 1);
    const firstLine = textEditor.document.lineAt(0);
    return new Range(firstLine.range.start, lastLine.range.end);
  }
}

TS1363

A type-only import can specify a default import or named bindings, but not both.

Broken Code ❌

import type MyDog, { MyPerson } from './MyPerson';
 
export function printAge(personOrDog: MyPerson | MyDog) {
  console.log(personOrDog.age);
}

Fixed Code ✔️

With type-only imports and exports you cannot use a default import together with a named import in one single line of code. The TypeScript team chose this limitation to avoid ambiguity. You will have to use separate import statements:

import type { MyPerson } from './MyPerson';
import type MyDog from './MyPerson';
 
export function printAge(personOrDog: MyPerson | MyDog) {
  console.log(personOrDog.age);
}

TS1368

Class constructor may not be a generator.

Broken Code ❌

class SomeClass {
  *constructor() {
    // ...
  }
}

Fixed Code ✔️

You can't name generators as constructor:

class SomeClass {
  *builder() {
    // ...
  }
}

TS1371

This import is never used as a value and must use 'import type' because 'importsNotUsedAsValues' is set to 'error'.

Broken Code ❌

MyPerson.ts

export class MyPerson {
  constructor(
    public name: string,
    public age: number
  ) {}
}

printAge.ts

import { MyPerson } from './MyPerson';
 
export function printAge(person: MyPerson) {
  console.log(person.age);
}

Fixed Code ✔️

Solution 1:

When "importsNotUsedAsValues" is set to "error" in your "tsconfig.json", then you have to use the "import type" syntax when you just want to refer to a type instead of using it as a value:

printAge.ts

import type { MyPerson } from './MyPerson';
 
export function printAge(person: MyPerson) {
  console.log(person.age);
}

Solution 2:

Use the class also as a value and not just a type:

printAge.ts

import { MyPerson } from './MyPerson';
 
export function printAge(person: MyPerson) {
  console.log(person.age);
}
 
const benny = new MyPerson('Benny', 35);
printAge(benny);

Solution 3:

You can also set "importsNotUsedAsValues" to "preserve" which is not recommended.

TS1375

'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module.

Broken Code ❌

const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');

Fixed Code ✔️

export {};
 
const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');

TS1378

Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher.

Broken Code ❌

tsconfig.json

{
  "compilerOptions": {
    "lib": ["es2017"],
    "module": "commonjs",
    "outDir": "dist",
    "rootDir": "src",
    "target": "es6"
  }
}

Fixed Code ✔️

tsconfig.json

{
  "compilerOptions": {
    "lib": ["es2017"],
    "module": "esnext",
    "outDir": "dist",
    "rootDir": "src",
    "target": "es2017"
  }
}

TS1385

Function type notation must be parenthesized when used in a union type.

Broken Code ❌

type MyCallback = () => number | () => string

Fixed Code ✔️

When using a union type, you have to put additional function types in parentheses:

type MyCallback = () => number | (() => string);

TS1389

'this' is not allowed as a variable declaration name.

Broken Code ❌

const this = 'something';

Fixed Code ✔️

The name this cannot be used to declare a variable because it is already a reserved keyword to refer to the current object in a method or constructor.

That's why you have to choose a different name:

const that = 'something';

TS1431

'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module.

Broken Code ❌

const inputStream = fs.createReadStream('file.csv');
 
const rl = readline.createInterface({
  input: inputStream,
  crlfDelay: Infinity,
});
 
for await (const line of rl) {
  console.log(line);
}

Fixed Code ✔️

Just add the imports for the fs module and readline module in order to turn your code into a module itself:

import fs from 'node:fs';
import readline from 'node:readline';
 
const inputStream = fs.createReadStream('file.csv');
 
const rl = readline.createInterface({
  input: inputStream,
  crlfDelay: Infinity,
});
 
for await (const line of rl) {
  console.log(line);
}

TS1432

Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher.

Broken Code ❌

start.ts

import fs from 'node:fs';
import readline from 'node:readline';
 
const file = 'abc.csv';
 
const fileStream = fs.createReadStream(file);
 
const rl = readline.createInterface({
  input: fileStream,
  crlfDelay: Infinity,
});
 
for await (const line of rl) {
  console.log(`Line from file: ${line}`);
}

tsconfig.json

{
  "compilerOptions": {
    "lib": ["es2017"],
    "module": "commonjs",
    "target": "es6"
  }
}

Fixed Code ✔️

The error is similar to TS1378 and needs an adjustment in the tsconfig.json file:

tsconfig.json

{
  "compilerOptions": {
    "lib": ["es2017"],
    "module": "esnext",
    "target": "es2017"
  }
}

TS1434

Unexpected keyword or identifier.

Broken Code ❌

class MyClass {
  static static ID: number = 1337;
}

Fixed Code ✔️

You have to remove the duplicate static keyword:

class MyClass {
  static ID: number = 1337;
}

TS1450

Dynamic imports can only accept a module specifier and an optional set of attributes as arguments.

Broken Code ❌

const Codeowners = import('codeowners');

This error occurs because the TypeScript compiler expects a dynamic import as the imported module is assigned to a constant.

Fixed Code ✔️

To fix this error, use an import statement to indicate to the compiler that a module is being imported:

import Codeowners from 'codeowners';

TS1470

The 'import.meta' meta-property is not allowed in files which will build into CommonJS output.

Broken Code ❌

import path from 'node:path';
import { fileURLToPath } from 'node:url';
 
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
 
console.log(`Hello from directory: ${__dirname}`);

Solution:

Since import.meta is not allowed when targeting CommonJS, you need to use an alternative method to determine the directory path. In a CommonJS environment, you can use the built-in __dirname global variable directly without needing to calculate it from __filename.

Fixed Code ✔️

import path from 'node:path';
 
console.log(`Hello from directory: ${__dirname}`);

TS1471

Module '@headlessui/react' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead.

Broken Code ❌

import { FocusTrap } from '@headlessui/react';

Fixed Code ✔️

Using a dynamic import:

const { FocusTrap } = await import('@headlessui/react');

TS1479

The current file is a CommonJS module whose imports will produce 'require' calls; however, the referenced file is an ECMAScript module and cannot be imported with 'require'. Consider writing a dynamic 'import()' call instead.

Broken Code ❌

import { createTempFile } from '@bennycode/utils';
const tempFile = await createTempFile('Hello, World', true);

Solution:

To import an ECMAScript module in a CommonJS module, you can use a dynamic import which works asynchronously and returns a Promise.

Fixed Code ✔️

const { createTempFile } = await import('@bennycode/utils');
const tempFile = await createTempFile('Hello, World', true);

TS1484

ContentCollectionKey is a type and must be imported using a type-only import when verbatimModuleSyntax is enabled.

Broken Code ❌

import { ContentCollectionKey, getCollection } from 'astro:content';

Fixed Code ✔️

Type-only imports can be made using the type keyword in front of your type's name:

import { type ContentCollectionKey, getCollection } from 'astro:content';

TS2300

Duplicate identifier 'name'.

Broken Code ❌

Objects don't support multiple properties with the same name:

const objectLiteral = {
  name: 'Benny',
  name: 'Sofia',
};

Fixed Code ✔️

To fix the error we have to remove the duplicated property:

const objectLiteral = {
  name: 'Sofia',
};

TS2304

Cannot find name 'world'.

Broken Code ❌

console.log(world.name);

Fixed Code ✔️

It can happen that TypeScript does not know about your global objects because those may be injected from an unknown runtime environment or third-party JavaScript library. The easiest way to let TypeScript know about this is to declare the ambience (ambient context):

declare var world: {
  name: string;
};
 
console.log(world.name);

Cannot find name 'Promise'

Broken Code ❌

// ...
 
public load_prekey(prekey_id: number): Promise<Proteus.keys.PreKey> {
  return new Promise((resolve) => {
    resolve(42);
  });
}
 
// ...

Fixed Code ✔️

Install es6-promise type definitions with the typings tool.

typings install dt~es6-promise --global --save

Adding the following line to the beginning of every file using definitions from es6-promise.

/// <reference path='es6-promise.d.ts' />
 
...
 
public load_prekey(prekey_id: number): Promise<Proteus.keys.PreKey> {
  return new Promise((resolve) => {
    resolve(42);
  });
}
 
...

Cannot find name 'Promise'

Broken Code ❌

const UUID = require('uuidjs');

Fixed Code ✔️

npm install @types/node --save-dev

Cannot find name 'FC'.

Broken Code ❌

import React from 'react';
 
const App: FC = (): JSX.Element => {
  return <></>;
};

Fixed Code ✔️

import React, { FC } from 'react';
 
const App: FC = (): JSX.Element => {
  return <></>;
};

TS2305

Module './sum' has no exported member 'multiply'.

Broken Code ❌

sum.ts

export function sum(a: number, b: number): number {
  return a + b;
}

main.ts

import { multiply } from './sum';
 
console.log(multiply(1, 2));

Fixed Code ✔️

The file "sum.ts" exports a function named "sum", so we have to fix the named import in our "main.ts" file:

main.ts

import { sum } from './sum';
 
console.log(sum(1, 2));

TS2306

File 'add.ts' is not a module.

Broken Code ❌

add.ts

function add(a: number, b: number): number {
  return a + b;
}

main.ts

import { add } from './add';
 
console.log(add(1000, 337));

Fixed Code ✔️

The error TS2306 signals that the file (add.ts) can be found (otherwise it would throw error TS2307) but does not provide the necessary exports. We can solve this with a named export:

add.ts

export function add(a: number, b: number): number {
  return a + b;
}

Alternatively, we can use a default export:

add.ts

export default function add(a: number, b: number): number {
  return a + b;
}

Using a default export requires that we also adjust our import statement in main.ts (otherwise we would end up with error TS2614):

main.ts

import add from './add';
 
console.log(add(1000, 337));

Video Tutorial

TS2307

Cannot find module 'events' or its corresponding type declarations.

Broken Code ❌

You are importing from a core Node.js module (e.g. event) without having Node.js type definitions installed:

import { EventEmitter } from 'events';

Fixed Code ✔️

Import Node.js type definitions first in order to use Node.js core modules:

npm install @types/node

TS2314

Generic type 'Omit' requires 2 type argument(s).

Broken Code ❌

export interface SerializedBatchedCandle extends Omit<BatchedCandle, 'close', 'open'> {
  open: string;
  close: string;
}

Fixed Code ✔️

When using the Omit utility type, you have to list property overwrites with a pipe (|):

export interface SerializedBatchedCandle extends Omit<BatchedCandle, 'close' | 'closeAsk'> {
  close: string;
  closeAsk: string;
}

Generic type 'ReadonlyArray ' requires 1 type argument(s).

Broken Code ❌

const array: ReadonlyArray = [1, 2, 3] as const;

Fixed Code ✔️

When using a generic (in this case ReadonlyArray<T>), then you have to pass a type argument to it:

const array: ReadonlyArray<number> = [1, 2, 3] as const;

TS2315

Type 'CustomRequest' is not generic.

Broken Code ❌

type CustomRequest = {
  url: string;
  data: string;
};
 
const request: CustomRequest<string> = {
  url: 'https://typescript.tv/',
  data: 'example',
};

Fixed Code ✔️

When supplying a type (recognizable by the use of the diamond operator <>), then we have to make sure that our type actually supports generics to capture the type that we provide:

type CustomRequest<CustomType> = {
  url: string;
  data: CustomType;
};
 
const request: CustomRequest<string> = {
  url: 'https://typescript.tv/',
  data: 'example',
};

TS2318

TS2318: Cannot find global type 'AsyncIterableIterator'.

Broken Code ❌

{
  "compilerOptions": {
    "target": "es2018",
    "module": "commonjs",
    "lib": ["es2018", "dom"],
    "strict": true,
    "esModuleInterop": true,
    "moduleResolution": "node"
  }
}

Solution:

This issue is often related to the TypeScript configuration not including the necessary libraries that define modern JavaScript features like AsyncIterableIterator. To ensure that TypeScript supports Symbol.asyncIterator properly, your TypeScript configuration needs to either target esnext or explicitly include the esnext.asynciterable library if you're using a targeted subset of features from ECMAScript proposals.

Fixed Code ✔️

{
  "compilerOptions": {
    "target": "es2018",
    "module": "commonjs",
    "lib": ["es2018", "dom", "esnext.asynciterable"],
    "strict": true,
    "esModuleInterop": true,
    "moduleResolution": "node"
  }
}

TS2322

Type 'string' is not assignable to type 'number'.

Broken Code ❌

export function add(a: number, b: number): number {
  return `${a + b}`;
}

Fixed Code ✔️

The type of the returned value must match the return type specified in the function signature:

export function add(a: number, b: number): number {
  return parseInt(`${a + b}`, 10);
}

Video Tutorial

TS2335

'super' can only be referenced in a derived class.

Broken Code ❌

abstract class Animal {
  abstract makeNoise(): string;
}
 
class Cat {
  constructor() {
    super();
  }
 
  makeNoise(): string {
    return 'Meow!';
  }
}

Fixed Code ✔️

Your derived class has to "extend" the base class:

abstract class Animal {
  abstract makeNoise(): string;
}
 
class Cat extends Animal {
  constructor() {
    super();
  }
 
  makeNoise(): string {
    return 'Meow!';
  }
}

TS2339

Property 'width' does not exist on type 'Shape'.

Broken Code ❌

type Shape = {
  kind: 'rectangle' | 'square';
};
 
type Rectangle = {
  kind: 'rectangle';
  width: number;
  height: number;
} & Shape;
 
type Square = {
  kind: 'square';
  size: number;
} & Shape;
 
function handleShape(shape: Shape): void {
  switch (shape.kind) {
    case 'rectangle':
      console.log(shape.width);
      break;
    case 'square':
      console.log(shape.size);
      break;
  }
}

Fixed Code ✔️

You can create discriminated unions by sharing a single field (e.g. kind) in your type definitions and using a union type in connection with a switch-case statement that helps the TypeScript compiler to distinguish the different types:

type Rectangle = {
  kind: 'rectangle';
  width: number;
  height: number;
};
 
type Square = {
  kind: 'square';
  size: number;
};
 
type Shape = Rectangle | Square;
 
function handleShape(shape: Shape): void {
  switch (shape.kind) {
    case 'rectangle':
      console.log(shape.width);
      break;
    case 'square':
      console.log(shape.size);
      break;
  }
}

Property 'pop' does not exist on type 'readonly [1, 2, 3]'.

Broken Code ❌

const array = [1, 2, 3] as const;
array.pop();

When using a const assertion on an array, then your array becomes readonly (immutable), so you cannot modify its elements using in-place operations such as pop. You will have to make your array mutable:

const array: number[] = [1, 2, 3];
array.pop();

TS2341

Property 'startSimulation' is private and only accessible within class 'ExchangeMock'.

Broken Code ❌

await exchange.startSimulation();

Solution:

Access the private property startSimulation using bracket notation, which is a workaround to access private members from outside the class in TypeScript.

Fixed Code ✔️

await exchange['startSimulation']();

TS2344

Type '{ name: string; }' does not satisfy the constraint '{ age: number; }'. Property 'age' is missing in type '{ name: string; }' but required in type '{ age: number; }'.

Broken Code ❌

function increaseAge<T extends { age: number }>(data: T): T {
  data.age += 1;
  return data;
}
 
increaseAge<{ name: string }>({ age: 25, name: 'Benny' });

Fixed Code ✔️

The "constraint" in this context is set by the T extends statement. When passing a type argument, the required properties of the type variable (T) must be matched:

function increaseAge<T extends { age: number }>(data: T): T {
  data.age += 1;
  return data;
}
 
increaseAge<{ age: number; name: string }>({ age: 25, name: 'Benny' });

As an alternative, type argument inference can be used:

function increaseAge<T extends { age: number }>(data: T): T {
  data.age += 1;
  return data;
}
 
increaseAge({ age: 25, name: 'Benny' });

TS2345

Argument of type 'number' is not assignable to parameter of type 'TimerHandler'.

Broken Code ❌

function add(a: number, b: number): number {
  return a + b;
}
 
setTimeout(add(1000, 337), 5000);

Fixed Code ✔️

There is a mismatch in the expected arguments of a function. The setTimeout function expects the first argument to be a callback function and not the returned value (in this case a number) of a function call:

function add(a: number, b: number): number {
  return a + b;
}
 
setTimeout(() => add(1000, 337), 5000);

Video Tutorial

TS2348

Value of type 'typeof BaseN' is not callable. Did you mean to include 'new'?

Broken Code ❌

import { BaseN } from 'js-combinatorics';
 
const iterator = BaseN([1, 2, 3], 2);

Fixed Code ✔️

import { BaseN } from 'js-combinatorics';
 
const iterator = new BaseN([1, 2, 3], 2);

TS2349

Cannot invoke an expression whose type lacks a call signature. Type 'Promise' has no compatible call signatures.

Broken Code ❌

function bugged(param: Promise<Object>): void {
  param().then(() => console.log('error TS2349'));
}

Fixed Code ✔️

function bugged(param: Promise<Object>): void {
  param.then(() => console.log('error TS2349'));
}

TS2350

Only a void function can be called with the 'new' keyword.

Broken Code ❌

return new NextResponse.json({ message: 'File received successfully' }, 200);

This error occurs because NextResponse.json() is a static method and not a constructor. Therefore, it shouldn't be used with the new keyword.

Fixed Code ✔️

Remove the new keyword when calling NextResponse.json():

return NextResponse.json({ message: 'File received successfully' }, 200);

This way, you're correctly invoking the static method without trying to instantiate it.

TS2351

This expression is not constructable. Type 'EMA' has no construct signatures.

Broken Code ❌

RSI.ts

export class RSI {
  private readonly avgGain: MovingAverage;
 
  constructor(
    private readonly interval: number,
    Indicator: EMA
  ) {
    this.avgGain = new Indicator(this.interval);
  }
}

EMA.ts

export class EMA {}

Fixed Code ✔️

RSI.ts

export class RSI {
  private readonly avgGain: MovingAverage;
 
  constructor(
    private readonly interval: number,
    Indicator: typeof EMA
  ) {
    this.avgGain = new Indicator(this.interval);
  }
}

TS2352

Conversion of type '{ name: string; age: number; }' to type 'Person' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.

Broken Code ❌

type Person = {
  firstName: string;
  age: number;
};
 
const myObject = {
  name: 'Benny',
  age: 34,
} as Person;

Fixed Code ✔️

Make sure all properties of your object match the properties of your declared type:

type Person = {
  firstName: string;
  age: number;
};
 
const myObject = {
  firstName: 'Benny',
  age: 34,
} as Person;

Alternative but not recommended: Convert your object to unknown first:

type Person = {
  firstName: string;
  age: number;
};
 
const myObject = {
  name: 'Benny',
  age: 34,
} as unknown as Person;

TS2353

TS2353: Object literal may only specify known properties, and 'id' does not exist in type Omit<VideoEntity, 'id'>.

Broken Code ❌

return VideoEntity.new({
  ytCode: item.snippet!.resourceId!.videoId!,
  id: -1,
});

Solution:

In the broken code, you are trying to set the id property on an instance of VideoEntity where id has been explicitly removed from the permissible properties through the use of Omit<VideoEntity, 'id'>.

Remove the id property from the object literal since it has been omitted from the type definition you are trying to conform to.

Fixed Code ✔️

return VideoEntity.new({
  ytCode: item.snippet!.resourceId!.videoId!,
});

TS2355

A function whose declared type is neither 'void' nor 'any' must return a value.

Broken Code ❌

getName(): string {
 
}

Fixed Code ✔️

getName(): string {
  return 'Benny';
}

TS2361

The right-hand side of an 'in' expression must not be a primitive.

Broken Code ❌

import axios, { AxiosError } from 'axios';
 
const isAxiosError = (error: unknown): error is AxiosError => {
  return 'isAxiosError' in error;
};

Fixed Code ✔️

You cannot use the in keyword on primitive data types. That's why we have to replace the primitive type unknown with a non-primitive type like object:

import axios, { AxiosError } from 'axios';
 
const isAxiosError = (error: object): error is AxiosError => {
  return 'isAxiosError' in error;
};

An alternative solution would be to use a type assertion on the right-hand side of the 'in' expression:

const isAxiosError = (error: unknown): error is AxiosError => {
  return 'isAxiosError' in (error as AxiosError);
};

TS2362

The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

Broken Code ❌

const userName = { name: 'Benny' };
const userAge = { age: 35 };
const user = userName & userAge;

Fixed Code ✔️

When you want to merge two objects, you have a multitude of possibilities:

Spread Syntax

const userName = { name: 'Benny' };
const userAge = { age: 35 };
const user = {
  ...userName,
  ...userAge,
};

Object.assign

const userName = { name: 'Benny' };
const userAge = { age: 35 };
const user = Object.assign({}, userName, userAge);

TS2364

The left-hand side of an assignment expression must be a variable or a property access.

Broken Code ❌

1 = 1;

Fixed Code ✔️

Using a variable on the left-hand side assignment:

const a = 1;

TS2365

Operator '+' cannot be applied to types 'number' and 'object'.

Broken Code ❌

export function add(a: number, b: object): number {
  return a + b;
}

Fixed Code ✔️

You can use the + operator only with equivalent data types (strings + strings or numbers + numbers):

export function add(a: number, b: number): number {
  return a + b;
}

TS2366

Function lacks ending return statement and return type does not include 'undefined'.

Broken Code ❌

export function getInterestRate(years: 1 | 2 | 3): number {
  switch (years) {
    case 1:
      return 1.75;
    case 2:
      return 2.96;
  }
}

Fixed Code ✔️

The switch-case statement isn't handling all cases from every possible input. We can solve that by defining a default case:

export function getInterestRate(years: 1 | 2 | 3): number {
  switch (years) {
    case 1:
      return 1.75;
    case 2:
      return 2.96;
    default:
      return 3;
  }
}

Another solution would be to implement the missing case for 3:

export function getInterestRate(years: 1 | 2 | 3): number {
  switch (years) {
    case 1:
      return 1.75;
    case 2:
      return 2.96;
    case 3:
      return 3;
  }
}

Video Tutorial

TS2367

This condition will always return 'false' since the types '{ message: string; }[] | undefined' and 'number' have no overlap.

Broken Code ❌

function myTest(errors: { message: string }[]): void {
  if (errors === 0) {
    throw new Error();
  }
}

Fixed Code ✔️

An array cannot be 0, so doing a check for equality with 0 makes no sense. What may be useful instead is checking the array length:

function myTest(errors: { message: string }[]): void {
  if (errors.length === 0) {
    throw new Error();
  }
}

TS2368

Type parameter name cannot be 'number'.

Broken Code ❌

export interface SimpleNumberIndicator<number> {
  update(price: T): T;
}

Fixed Code ✔️

The easiest way to fix the error is to make age optional as well:

export interface SimpleNumberIndicator<T = number> {
  update(price: T): T;
}

TS2369

A parameter property is only allowed in a constructor implementation.

Broken Code ❌

class MyMessenger {
  constructor(public message: string);
}

Fixed Code ✔️

The constructor implementation is missing curly brackets which is why TypeScript does not recognize the constructor implementation and files error TS2369. To solve it you have to add the missing curly brackets:

class MyMessenger {
  constructor(public message: string) {}
}

TS2370

A rest parameter must be of an array type.

Broken Code ❌

function sum(...array: number): number {
  return array.reduce((a, b) => a + b);
}
 
console.log(sum(...[1, 2, 3, 4, 5]));

Fixed Code ✔️

A rest parameter allows a function to accept an indefinite number of parameters. To signal that it can be multiple values, we have to use an array type for our rest parameter:

function sum(...array: number[]): number {
  return array.reduce((a, b) => a + b);
}
 
console.log(sum(...[1, 2, 3, 4, 5]));

TS2371

A parameter initializer is only allowed in a function or constructor implementation.

Broken Code ❌

function add(a: number, b: number, c: number = 0): number;
function add(a: number | string, b: number | string, c: number | string = 0): number {
  return parseInt(`${a}`, 10) + parseInt(`${b}`, 10);
}

Fixed Code ✔️

Remove parameter initializer from function overload:

function add(a: number, b: number, c: number): number;
function add(a: number | string, b: number | string, c: number | string = 0): number {
  return parseInt(`${a}`, 10) + parseInt(`${b}`, 10);
}

TS2372

Parameter 'score' cannot reference itself.

Broken Code ❌

function printScore(score: number = score): void {
  console.log(score);
}

Fixed Code ✔️

If you want to use a default value for a parameter, then you have to set it to a fixed value instead of referencing the parameter to itself:

function printScore(score: number = 0): void {
  console.log(score);
}

TS2377

Constructors for derived classes must contain a 'super' call.

Broken Code ❌

abstract class Animal {
  abstract name: string;
}
 
class Dog extends Animal {
  public name;
 
  constructor(name: string) {
    this.name = name;
  }
}

Fixed Code ✔️

Every constructor in a derived class has to call the super method to invoke the constructor of the base class. It has to be the very first call:

abstract class Animal {
  abstract name: string;
}
 
class Dog extends Animal {
  public name;
 
  constructor(name: string) {
    super();
    this.name = name;
  }
}

Video Tutorial

TS2378

A 'get' accessor must return a value.

Broken Code ❌

get name() {
 
}

Fixed Code ✔️

get name(): string {
  return 'Benny';
}

TS2383

TS2383: Overload signatures must all be exported or non-exported.

Broken Code ❌

function isTuple<T>(arr: T[], minLength: 1): arr is [T];
function isTuple<T>(arr: T[], minLength: 2): arr is [T, T];
function isTuple<T>(arr: T[], minLength: 3): arr is [T, T, T];
function isTuple<T>(arr: T[], minLength: 4): arr is [T, T, T, T];
export function isTuple<T>(arr: T[], minLength: number) {
  return arr.length >= minLength;
}

Solution:

This TypeScript error occurs because the function overloads for isTuple are internally defined (not exported), but the implementation signature is exported. This discrepancy between the visibility of the overload signatures and the implementation signature leads to the error.

To fix this error, you need to ensure consistent export status for all overload signatures and the function implementation. You can either export all the overload signatures or keep them all internal. In most cases, if you intend to use the function outside the module, you should export everything.

Fixed Code ✔️

export function isTuple<T>(arr: T[], minLength: 1): arr is [T];
export function isTuple<T>(arr: T[], minLength: 2): arr is [T, T];
export function isTuple<T>(arr: T[], minLength: 3): arr is [T, T, T];
export function isTuple<T>(arr: T[], minLength: 4): arr is [T, T, T, T];
export function isTuple<T>(arr: T[], minLength: number) {
  return arr.length >= minLength;
}

TS2389

Function implementation name must be 'getOpenPosition'.

Broken Code ❌

async getOpenPosition(): Promise<PortfolioOpenPosition[]>;
async getOpenPosition(id: number): Promise<OrderSchema>;
async getOrder(id?: number) {
  const resource = OrderAPI.URL.ORDERS;
  const response = await this.apiClient.get(resource);
  return z.array(OrderSchema).parse(response.data);
}

Solution:

Rename getOrder to getOpenPosition to match the declared method signatures.

Fixed Code ✔️

async getOpenPosition(): Promise<PortfolioOpenPosition[]>;
async getOpenPosition(id: number): Promise<OrderSchema>;
async getOpenPosition(id?: number) {
  const resource = OrderAPI.URL.ORDERS;
  const response = await this.apiClient.get(resource);
  return z.array(OrderSchema).parse(response.data);
}

TS2390

Constructor implementation is missing.

Broken Code ❌

class MyMessenger {
  constructor(public message: string);
}

Fixed Code ✔️

A constructor implementation must be put in curly brackets:

class MyMessenger {
  constructor(public message: string) {}
}

TS2391

Function implementation is missing or not immediately following the declaration.

Broken Code ❌

abstract class Animal {
  abstract name: string;
  makeNoise(): string;
}

Fixed Code ✔️

An abstract class is different from an interface. You have to use the abstract modifier if you want to define a contract in an abstract class. If there is no abstract modifier you will have to provide a implementation.

Solution 1:

To solve the problem, we can mark makeNoise with the abstract keyword. That will enforce derived classes to implement this method on their own:

abstract class Animal {
  abstract name: string;
  abstract makeNoise(): string;
}

Solution 2:

Another solution is to provide a base implementation for makeNoise:

abstract class Animal {
  abstract name: string;
  makeNoise(): string {
    return 'Woof';
  }
}

Video Tutorial

TS2393

Duplicate function implementation.

Broken Code ❌

function add(a: number, b: number) {
  return a + b;
}

Fixed Code ✔️

This error may occur when you have multiple files within the same project that implement the same function with the same name. To resolve this issue, you need to configure TypeScript to recognize a file as a script rather than a module. This can be achieved by setting the "moduleDetection" option to "force" instead of the default "auto":

tsconfig.json

{
  "compilerOptions": {
    "moduleDetection": "force"
  }
}

TS2394

This overload signature is not compatible with its implementation signature.

Broken Code ❌

The implementation does not match all signatures:

function sum(a: number, b: number): number;
function sum(a: string, b: string): string;
function sum(a: number | string, b: number | string) {
  return `${parseInt(a + '', 10) + parseInt(b + '', 10)}`;
}

Fixed Code ✔️

To match the first function overload, we have to add code to our function body which can also return a number:

function sum(a: number, b: number): number;
function sum(a: string, b: string): string;
function sum(a: number | string, b: number | string) {
  if (typeof a === 'number' && typeof b === 'number') {
    return a + b;
  }
  return `${parseInt(a + '', 10) + parseInt(b + '', 10)}`;
}

Video Tutorial

TS2395

Individual declarations in merged declaration 'React' must be all exported or all local.

Broken Code ❌

index.d.ts

import * as React from 'react';
 
declare namespace React {
  type StatelessComponent<P> = React.FunctionComponent<P>;
}

Fixed Code ✔️

Make sure to export your additional declaration:

index.d.ts

import * as React from 'react';
 
export declare namespace React {
  type StatelessComponent<P> = React.FunctionComponent<P>;
}

TS2397

Declaration name conflicts with built-in global identifier 'globalThis'.