How to fix Duplicate identifier 'X' in TypeScript

What this error means

TypeScript enforces a strict rule that each identifier must be uniquely declared within its scope. When the TypeScript compiler encounters two or more declarations with the same name in the same scope, it emits error TS2300: Duplicate identifier. This error commonly appears in several scenarios: 1. **Accidental duplicate declarations**: You've declared the same interface, type, variable, or function twice in the same file 2. **Conflicting type definitions**: Multiple versions of @types packages or global type declarations conflict 3. **Script vs. module files**: Files without imports/exports are treated as global scripts, causing name collisions across your entire project 4. **Circular dependencies**: Two modules import from each other, creating duplicate type definitions The error is particularly common when working with declaration files (.d.ts), third-party type definitions from @types packages, or when migrating JavaScript code to TypeScript. Global scope pollution is a frequent culprit—any file without at least one import or export statement is considered a global script rather than a module.

Typical symptoms

• TypeScript compilation fails with error TS2300: Duplicate identifier
• Red squiggly lines under interface, type, or variable declarations in your IDE
• Error message appears for identifiers that you've only declared once in your file
• Conflicts appear after installing or updating @types packages (like @types/node)
• Problems arise when multiple declaration files (.d.ts) are included in your project
• Error occurs for common names like 'Buffer', 'process', 'Error', or 'Node'
• Code works fine in one file but breaks when you add another file to the project

Common causes

1. The same interface, type, class, or variable is declared twice in the same file
2. Your file doesn't contain any import/export statements, making it a global script
3. Multiple versions of the same @types package are installed in node_modules
4. Conflicting type definitions from different libraries declare the same global name
5. You're importing declaration files that define the same ambient types
6. Circular module dependencies cause type definitions to be processed multiple times
7. Legacy typings and modern @types packages both define the same types
8. Two different files in your project declare the same global interface or type

How to fix "Duplicate identifier 'X'"

// WRONG - duplicate interface declaration
interface User {
  name: string;
}

interface User {
  email: string;
}

// WRONG - duplicate variable
const API_URL = "https://api.example.com";
const API_URL = "https://staging.api.example.com";

// CORRECT - single merged interface
interface User {
  name: string;
  email: string;
}

// CORRECT - single variable
const API_URL = "https://api.example.com";

// BEFORE - global script (problematic)
interface Result {
  success: boolean;
}

const calculate = () => {
  // ...
};

// AFTER - module (isolated scope)
interface Result {
  success: boolean;
}

const calculate = () => {
  // ...
};

// Add this line to make it a module
export {};

# List all @types packages
npm ls @types

# Look for duplicates or multiple versions
npm ls @types/node

# Update to latest version
npm install --save-dev @types/node@latest

# Remove and reinstall all dependencies
rm -rf node_modules package-lock.json
npm install

# Deduplicate packages
npm dedupe

{
  "compilerOptions": {
    "skipLibCheck": true
  }
}

// BEFORE - conflict if both export 'Result'
import { Result } from "./api";
import { Result } from "./database"; // Error: Duplicate identifier 'Result'

// AFTER - use aliases
import { Result as ApiResult } from "./api";
import { Result as DbResult } from "./database";

// Now use them distinctly
const apiData: ApiResult = { success: true };
const dbData: DbResult = { rows: [] };

{
  "compilerOptions": {
    "skipLibCheck": true
  },
  "include": ["src/**/*"],
  "exclude": [
    "node_modules",
    "**/*.spec.ts",
    "legacy-typings/**/*"
  ]
}

npx tsc --traceResolution | grep "duplicate-identifier-name"

Advanced notes

// These will merge successfully
interface Window {
  customProperty: string;
}

interface Window {
  anotherProperty: number;
}

// Result: Window has both customProperty and anotherProperty

// ERROR - conflicting property types
interface Config {
  timeout: string;
}

interface Config {
  timeout: number; // Error: Duplicate identifier with different type
}

// script-file.ts (DANGEROUS - global scope)
const sharedValue = 100;

// another-script.ts (DANGEROUS - same global scope)
const sharedValue = 200; // Error: Duplicate identifier

// Legacy namespace approach
namespace MyApp {
  export interface User {
    name: string;
  }
}

// Modern module approach
export interface User {
  name: string;
}

// If both exist, you get duplicate identifier errors

// a.ts
import { TypeB } from "./b";
export interface TypeA {
  b: TypeB;
}

// b.ts
import { TypeA } from "./a";
export interface TypeB {
  a: TypeA; // Circular reference
}

// types.ts
export interface TypeA {
  b: TypeB;
}

export interface TypeB {
  a: TypeA;
}

// a.ts
import type { TypeA, TypeB } from "./types";

// b.ts
import type { TypeA, TypeB } from "./types";

// global.d.ts
declare global {
  interface Window {
    myCustomAPI: {
      version: string;
    };
  }
}

export {}; // Makes this a module

Frequently asked questions

What does "TS2300" mean?

TypeScript enforces a strict rule that each identifier must be uniquely declared within its scope. When the TypeScript compiler encounters two or more declarations with the same name in the same scope, it emits error TS2300: Duplicate identifier. This error commonly appears in several scenarios: 1.

How do I fix "TS2300"?

This TypeScript compiler error occurs when the same identifier (variable, type, interface, or class) is declared multiple times in the same scope. The fix involves removing duplicate declarations, fixing conflicting type definitions, or converting script files to modules.

What causes "TS2300"?

The same interface, type, class, or variable is declared twice in the same file Your file doesn't contain any import/export statements, making it a global script Multiple versions of the same @types package are installed in node_modules

Is the "TS2300" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• 'emitDecoratorMetadata' requires 'experimentalDecorators' to be enabled

  'emitDecoratorMetadata' requires 'experimentalDecorators' to be enabled

  MEDIUM

• Duplicate constructor definition

  How to fix 'Duplicate constructor definition' error in TypeScript

  MEDIUM

• Enum member must have initializer

  Enum member must have initializer

  MEDIUM

• 'downlevelIteration' is required for iterating over complex types

  'downlevelIteration' is required for iterating over complex types

  MEDIUM

• Cannot find name 'process'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.

  How to fix "Cannot find name 'process'" in TypeScript

  MEDIUM

• Module has no exported member 'X'

  How to fix 'Module has no exported member X' error in TypeScript

  MEDIUM

Official resources & further reading

• 📚TypeScript Official Documentation
• 📖
  TypeScript Handbook - Modules(Official Docs)
• 📖
  TypeScript Handbook - Declaration Merging(Official Docs)
• 📖
  TypeScript TSConfig - skipLibCheck(Official Docs)
• 🐙
  TypeScript GitHub - TS2300 Issues(GitHub)
• bobbyhadz - Duplicate identifier error in TypeScript
• Minko Gechev - Managing ambient type definitions
• Christos Monogios - How to fix the duplicate identifier error
• Stack Overflow - TypeScript TS2300 Questions