How to fix Merge of interface 'X' failed in TypeScript

# Search for interface declarations
grep -r "interface X" src/ --include="*.ts" --include="*.tsx" --include="*.d.ts"

# Search in node_modules for library declarations
find node_modules -name "*.d.ts" -exec grep -l "interface X" {} \; 2>/dev/null

# Check global augmentations
grep -r "declare global" src/ --include="*.ts" --include="*.d.ts"

// DECLARATION 1 (in file1.ts)
interface User {
  id: string;
  name: string;
  age: number;
}

// DECLARATION 2 (in file2.ts) - CONFLICT: age is string vs number
interface User {
  id: string;
  name: string;
  age: string;  // CONFLICT: Different type than declaration 1
}

// SOLUTION: Make types compatible
interface User {
  id: string;
  name: string;
  age: number | string;  // Union type accepts both
}

// ALTERNATIVE: Use type intersection if appropriate
type User = {
  id: string;
  name: string;
  age: number;
} & {
  age?: string;  // Optional string age
};

// DECLARATION 1
interface ApiClient {
  fetchData(url: string): Promise<Response>;
}

// DECLARATION 2 - CONFLICT: Different parameter type
interface ApiClient {
  fetchData(url: URL): Promise<Response>;  // Won't merge with string parameter
}

// SOLUTION 1: Make signatures identical
interface ApiClient {
  fetchData(url: string | URL): Promise<Response>;  // Accept both
}

// SOLUTION 2: Use function overloads in a single declaration
interface ApiClient {
  fetchData(url: string): Promise<Response>;
  fetchData(url: URL): Promise<Response>;
}

// SOLUTION 3: Separate the interfaces if truly different
interface StringApiClient {
  fetchData(url: string): Promise<Response>;
}

interface UrlApiClient {
  fetchData(url: URL): Promise<Response>;
}

// DECLARATION 1
interface Container<T extends string> {
  value: T;
}

// DECLARATION 2 - CONFLICT: Different constraint
interface Container<T extends number> {  // Won't merge with string constraint
  value: T;
}

// SOLUTION: Use identical constraints
interface Container<T extends string | number> {
  value: T;
}

// OR separate into different interfaces
interface StringContainer<T extends string> {
  value: T;
}

interface NumberContainer<T extends number> {
  value: T;
}

// For complex cases, use conditional types
interface Container<T> {
  value: T extends string ? T : T extends number ? T : never;
}

// WRONG: Trying to merge incorrectly
interface SomeLibraryInterface {
  newMethod(): void;  // May conflict with library's declaration
}

// CORRECT: Use module augmentation
declare module "some-library" {
  interface SomeLibraryInterface {
    newMethod(): void;  // Properly augments the library's interface
  }
}

// For global types (Window, Document, etc.):
declare global {
  interface Window {
    myCustomProperty: string;
  }

  interface Document {
    newMethod(): void;
  }
}

// For ambient declarations in .d.ts files:
// types/custom.d.ts
declare interface MyGlobalInterface {
  extendedProperty: boolean;
}

// In your source code, this will merge with other declarations
interface MyGlobalInterface {
  anotherProperty: string;
}

# Check for conflicting @types packages
npm list @types/some-library

# If multiple versions exist, resolve them
npm uninstall @types/some-library-old
npm install @types/some-library@latest

# Or use type patching with patch-package
npm install patch-package --save-dev

npm update @types/node @types/react @types/express

// When library types conflict with yours
import { SomeType } from "some-library";

// Use your own type definition
interface MyType extends Omit<SomeType, "conflictingProperty"> {
  conflictingProperty: string;  // Your preferred type
}

// Or use type merging with careful constraints
type MergedType = SomeType & {
  conflictingProperty?: string;  // Make optional to avoid conflict
};

// types/custom.d.ts
declare module "problematic-library" {
  export interface FixedInterface {
    // Your corrected type definitions
  }
}

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