How to fix Duplicate identifier 'X' in TypeScript

First, search your file for the duplicate identifier. Look for multiple declarations:

// 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";

Remove or merge the duplicates:

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

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

For interfaces, TypeScript supports declaration merging when declarations are compatible, but it's clearer to have a single declaration.

If your file doesn't have any import or export statements, TypeScript treats it as a global script. This causes all declarations to pollute the global namespace and conflict with other files.

Add an export to convert it to a module:

// 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 {};

Now your declarations won't conflict with other files. The export {} is an empty export that signals to TypeScript that this is a module file.

Check for duplicate or conflicting @types packages:

# List all @types packages
npm ls @types

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

Common fixes:

# 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

After cleaning up, restart your TypeScript server in VS Code:
- Press Ctrl+Shift+P (or Cmd+Shift+P on Mac)
- Type "TypeScript: Restart TS Server"
- Press Enter

If the duplicates are coming from third-party type definitions that you can't control, enable skipLibCheck in your tsconfig.json:

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

This tells TypeScript to skip type-checking for all declaration files (.d.ts), which can resolve conflicts from external packages. However, this is a workaround—it's better to fix the root cause if possible.

Note: This option improves compilation speed and works around third-party type issues, but you'll lose type-checking for those libraries.

If two modules export the same name and you need both, use import aliasing:

// 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: [] };

This pattern is especially useful when different libraries export types with common names like Config, Options, or Response.

If specific declaration files are causing conflicts, exclude them from compilation:

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

Common exclusion patterns:
- Legacy typings folders
- Duplicate declaration files
- Test files that declare global test types
- Build output directories

Use the tsc --traceResolution command to see which files TypeScript is including and identify the source of duplicates:

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