Зачем писать возвращаемый тип защиты типа как «это (…) и это» в TypeScript?

Я читаю раздел Классы в справочнике, но есть разница, которая меня смущает.

В следующих примерах:

1. В примере 1 они сначала явно написали тип возвращаемого значения this is Networked & this. Я могу понять эту часть.

2. Тогда в примере 2 они сделали только this is { value: T }, но тип box в блоке if — Box<string> & { value: string; }.

Я не знаю, почему работает второй случай. Основываясь на первом примере, я ожидаю, что вместо этого должно быть this is { value: T } & this. Означает ли это, что я всегда могу опустить явное & this?

Пример 1

class FileSystemObject {
  isFile(): this is FileRep {
    return this instanceof FileRep;
  }
  isDirectory(): this is Directory {
    return this instanceof Directory;
  }
  isNetworked(): this is Networked & this { // the return type here.
    return this.networked;
  }
  constructor(public path: string, private networked: boolean) {}
}
 
class FileRep extends FileSystemObject {
  constructor(path: string, public content: string) {
    super(path, false);
  }
}
 
class Directory extends FileSystemObject {
  children: FileSystemObject[];
}
 
interface Networked { // this interface that matters.
  host: string;
}
 
const fso: FileSystemObject = new FileRep("foo/bar.txt", "foo");
 
if (fso.isFile()) {
  fso.content;
} else if (fso.isDirectory()) {
  fso.children;
} else if (fso.isNetworked()) {
  fso.host; // const fso: Networked & FileSystemObject
}

Пример 2

class Box<T> {
  value?: T;
 
  hasValue(): this is { value: T } { // here, there is no `& this`.
    return this.value !== undefined;
  }
}
 
const box = new Box<string>();
box.value = "Gameboy";
 
if (box.hasValue()) {
  box.value; // notice the type of box here.
}