How to fix Export declaration conflicts with exported declaration of 'X' in TypeScript

What this error means

The "Export declaration conflicts with exported declaration" error (TS2484) appears when TypeScript detects that you're trying to export the same symbol name more than once from a module. This typically happens in one of two scenarios: either you have genuinely duplicate exports (exporting the same variable/type/class twice), or you're using re-export syntax (`export { SymbolName }`) in a context where it conflicts with another export. TypeScript enforces that each exported symbol must have a unique name within a module's export namespace. When the compiler encounters two exports with identical names, it cannot determine which one should be exposed to consumers of the module, resulting in this error. The error is particularly common when: 1. **Re-export statements in module augmentation**: Using `export { SymbolName }` syntax instead of inline exports when augmenting modules 2. **Combined declaration files**: Multiple modules exporting the same symbol get merged into a single index.d.ts file 3. **Declaration merging conflicts**: Attempting to merge declarations incorrectly across files 4. **Accidental duplicate exports**: The same variable is exported both inline and in an export block

Typical symptoms

• Compilation fails with 'Export declaration conflicts with exported declaration of' followed by the symbol name
• Error code TS2484 appears in compiler output
• Type declaration files (.d.ts) show duplicate export errors
• Module augmentation fails when using export clauses
• Error occurs in combined/bundled declaration files but not in source files
• IDE shows red underlines on export statements even though logic seems correct

Common causes

1. Using re-export syntax (export { X }) instead of inline exports in module augmentation
2. The same symbol is exported twice in the same file (once inline, once in export block)
3. Multiple declaration files export the same global symbol (e.g., 'Buffer' from different @types packages)
4. Conflicting type definitions when bundling multiple modules into a single .d.ts file
5. Attempting to export both a type and value with the same name from different sources
6. Module augmentation with export clauses conflicts with existing module exports
7. Incorrect declaration merging when extending third-party library types

How to fix "Export declaration conflicts with exported declaration of 'X'"

// WRONG - This can cause TS2484 in module augmentation
class MyClass {
  // ...
}
export { MyClass };

// CORRECT - Use inline export declaration
export class MyClass {
  // ...
}

// WRONG
function helperFunction() {
  return "data";
}
export { helperFunction };

// CORRECT
export function helperFunction() {
  return "data";
}

// WRONG - Duplicate exports
export const API_KEY = "abc123";

// Later in the same file...
export { API_KEY };  // Error: conflicts with earlier export

// CORRECT - Export once only
export const API_KEY = "abc123";

# Check for duplicate exports
grep "export.*SymbolName" src/yourfile.ts

// module-a.ts
export interface Config {
  timeout: number;
}

// module-b.ts - WRONG: same name causes conflict in combined .d.ts
export interface Config {
  retries: number;
}

// module-b.ts - CORRECT: use unique name or namespace
export interface NetworkConfig {
  retries: number;
}

// Or use namespaces to avoid conflicts
export namespace ModuleB {
  export interface Config {
    retries: number;
  }
}

// index.ts
export { Config as DatabaseConfig } from "./db/config";
export { Config as APIConfig } from "./api/config";

// WRONG - Can cause conflicts with export clause
declare module "express" {
  interface Request {
    user?: User;
  }
  export { Request };  // This can conflict
}

// CORRECT - Let declaration merging handle it
declare module "express" {
  interface Request {
    user?: User;
  }
}

// CORRECT - Use inline export in augmentation
declare module "my-lib" {
  export interface NewFeature {
    enabled: boolean;
  }
}

// tsconfig.json
{
  "compilerOptions": {
    "skipLibCheck": true
  }
}

# Example: Conflicting Buffer definitions
# from @types/node and another package
npm install @types/node@latest --save-dev

# List all installed type packages
npm list | grep @types

# Check for duplicate versions
npm ls @types/node

# Remove duplicates by ensuring compatible versions
npm dedupe

# Or explicitly install a single version
npm install @types/node@^20.0.0 --save-dev --save-exact

# Check which packages are pulling in conflicting types
npm ls @types/packagename

# Use resolutions field in package.json (npm 8.3+)
{
  "overrides": {
    "@types/node": "^20.0.0"
  }
}

rm -rf node_modules package-lock.json
npm install

Advanced notes

// Good pattern for module augmentation
declare module "express-serve-static-core" {
  interface Request {
    user?: User;
  }
}

// Augmenting with new exports
declare module "my-library" {
  export interface ExtendedConfig extends Config {
    newOption: boolean;
  }

  export function newHelperFunction(): void;
}

export class MyClass {}
export interface MyInterface {}
export function myFunction() {}

class MyClass {}
interface MyInterface {}
function myFunction() {}

export { MyClass, MyInterface, myFunction };

// src/moduleA.ts
export interface Config {
  optionA: boolean;
}

// src/moduleB.ts
export interface Config {  // Conflict when bundled
  optionB: boolean;
}

// src/moduleA.ts
export namespace ModuleA {
  export interface Config {
    optionA: boolean;
  }
}

// src/moduleA.ts
export interface ModuleAConfig {
  optionA: boolean;
}

// Ensure each module maintains its own scope
export default {
  input: {
    moduleA: 'src/moduleA.ts',
    moduleB: 'src/moduleB.ts'
  },
  output: {
    dir: 'dist',
    format: 'es'
  }
}

# Search for all export statements
grep -rn "export.*SymbolName" src/

# Find duplicate declarations
grep -rn "^export (class|interface|type|const|function) SymbolName" src/

npx tsc --declaration --emitDeclarationOnly

# Check generated .d.ts files for conflicts
cat dist/index.d.ts | grep "export.*SymbolName"

// This is fine - same name, same entity
export interface User {
  name: string;
}

// This causes conflict - User is both type and value
export const User = {
  create: () => ({ name: "" })
};

// Solution: Use different names
export interface UserType {
  name: string;
}

export const UserFactory = {
  create: (): UserType => ({ name: "" })
};

// Or use namespace for grouping
export namespace User {
  export interface Type {
    name: string;
  }

  export const create = (): Type => ({ name: "" });
}

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

  // WRONG - conflicts with built-in Buffer
  interface Buffer {
    customMethod(): void;
  }

  // CORRECT - extend existing Buffer instead
  // (requires @types/node)
  namespace NodeJS {
    interface Buffer {
      customMethod(): void;
    }
  }
}

export {};  // Make this a module

Frequently asked questions

What does "TS2484" mean?

The "Export declaration conflicts with exported declaration" error (TS2484) appears when TypeScript detects that you're trying to export the same symbol name more than once from a module. This typically happens in one of two scenarios: either you have genuinely duplicate exports (exporting the same variable/type/class twice), or you're using re-export syntax (export { SymbolName }) in a context where it conflicts with another export. TypeScript enforces that each exported symbol must have a unique name within a module's export namespace.

How do I fix "TS2484"?

This TypeScript error occurs when you attempt to export the same symbol name multiple times from a module, or when using re-export statements in module augmentation. The fix involves using direct export declarations instead of re-export syntax, or renaming conflicting exports.

What causes "TS2484"?

Using re-export syntax (export { X }) instead of inline exports in module augmentation The same symbol is exported twice in the same file (once inline, once in export block) Multiple declaration files export the same global symbol (e.g., 'Buffer' from different @types packages)

Is the "TS2484" error serious?

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

Related errors

• Exported variable 'X' has or is using name 'Y' from external module 'Z' but cannot be named

  How to fix 'Exported variable has or is using name from external module but cannot be named' in TypeScript

  MEDIUM

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

  How to fix 'experimentalDecorators option is not set' error in TypeScript

  MEDIUM

• Cannot use expression in template literal type

  Cannot use expression in template literal type

  MEDIUM

• Expected 2-3 arguments, but got 1

  How to fix 'Expected 2-3 arguments, but got 1' error in TypeScript

  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 Issue #26086 - Export declaration conflicts with exported declaration of 'Buffer'(GitHub)
• 🐙
  TypeScript Issue #7337 - Export declaration conflicts makes the compiler throw(GitHub)
• 🐙
  TypeScript Issue #9639 - Declaration merging conflicts when using export statement(GitHub)
• 📖
  TypeScript Handbook - Declaration Merging(Official Docs)
• 📖
  TypeScript Handbook - Namespaces and Modules(Official Docs)
• 🐙
  TypeScript Issue #48121 - Conflict between imported namespace and global type(GitHub)
• BobbyHadz - Duplicate identifier error in TypeScript
• Minko Gechev - Managing ambient type definitions and dealing with duplicate identifier errors