Typescript hierarchical inheritance

Question

Consider the following:

class A {
  commonString: string = "common";
}
class B extends A {
  bString: string = "b";
}
class C extends A {
  cString: string = "c";
}

It seems to me like a perfectly ordinary example of inheritance - one of the most basic, in fact. And yet, if I'm reading this documentation right, TypeScript's inheritance mechanism does not support this pattern?

I find this difficult to believe, for two reasons:

1. It's nonsense. Combining common fields and methods is basically THE REASON you use classes. If all you need is to ensure adherence to a contract, just use interfaces.
2. It appears to be false? The example code above is code I wrote into a typescript file, and it seems to work fine. b: B = B() behaves as expected: if I access b.bString it's fine, if I access b.cString it errors, if I store b: A = new B(), it works but compile-errors if I access b.bString (but at runtime bString is in fact present). It behaves exactly as I'd expect.

So, what's going on here? Have I misunderstood "hierarchical inheritance"? Does typescript claim not to support it, but really it does? Has my compiler been blessed by gnomes?

More to the point, can I trust the usual "B extends A, and also C extends A" to continue to work as expected?