同じ構造の型でもtypeかinterfaceかで割り当て可能性が異なる

Question

下記のようなObj型を定義します。

type Obj = { a: number; b: string } & {
    [x: string]: Obj[] | Obj[keyof Obj]
};

また、下記のような構造の型および変数を定義します。

declare const test: Outer[];

type Outer = {
    a: number;
    b: string;
    xxx: Array<Inner>;
};

type Inner = {
    a: number;
    b: string;
    yyy: Array<Innermost>;
};

type Innermost = {
    a: number;
    b: string;
};

このとき、下記testFn()への引数の割当は問題なく行えます。

declare function testFn(arg: Obj[]): void;
testFn(test); // OK

さて、ここで、上記Outer Inner Innermostと同じ構造となるような型をinterfaceで設計します。

declare const testInterface: OuterInterface[];

interface OuterInterface {
    a: number;
    b: string;
    xxx: Array<InnerInterface>;
}

interface InnerInterface {
    a: number;
    b: string;
    yyy: Array<InnermostInterface>;
}

interface InnermostInterface {
    a: number;
    b: string;
}

ところが、このtestInterfaceはtestFn()への割当が失敗してしまいます。

testFn(testInterface); // Index signature for type 'string' is missing in type 'OuterInterface'.

このようなtypeとinterfaceで割当可能性が異なる原因について、ご存じの方がいらっしゃればご教示いただけますと幸いです。

ちなみに、OuterおよびOuterInterfaceは相互に割り当て可能になりそうです・・・

declare let outerArray: Outer[];
declare let outerInterfaceArray: OuterInterface[];

outerArray = outerInterfaceArray; // OK
outerInterfaceArray = outerArray; // OK

• Playground