Allow extending multiple interfaces with different, but compatible types

interface Change {
  uid: string;
  type: string;
}

interface SomeChangeExtension {
  type: 'some';
  foo: number;
}

interface SomeChange extends Change, SomeChangeExtension { }

In this example, I was expecting SomeChange to have a type equivalent to:

interface SomeChange {
  uid: string;
  type: 'some';
  foo: number;
}

But it would result in error:

Interface 'SomeChange' cannot simultaneously extend types 'Change' and 'SomeChangeExtension'.
  Named property 'type' of types 'Change' and 'SomeChangeExtension' are not identical.

In this case, 'some' is compatible with string if the order of interfaces being extended is respected.

The reason why I want this to be allowed is that, I need to maintain multiple interfaces of the same kind of change during different stages: raw change, change, broadcast change. And having to duplicate part of the “extension” on every of them doesn’t look good.

[vilic]

@mhegazy I was thinking about respect the extensions order, and if the later one is compatible with the former one, then use the later one instead.

E.g.:

interface You {
  name: string;
  value: number;
}

interface FooYou {
  name: 'foo';
}

interface ConcreteFooYou extends You, FooYou {
  concrete: boolean;
}

In which ConcreteFooYou should be equivalent to:

interface ConcreteFooYou {
  name: 'foo';
  value: number;
  concrete: boolean;
}

[Mmoks]

@vilic This should help you

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

interface Change {
  uid: string;
  type: string;
}

interface SomeChangeExtension {
  type: 'some';
  foo: number;
  amount: number;
}

interface SomeChange extends Change, Omit<SomeChangeExtension, 'foo' | 'amount'> {
 foo: string;
 amount: string;
}