This is the case for literally all interpreted languages, and is an inherent part of them being interpreted.

It's actually the opposite. The idea of "types" is almost entirely made up by compilers and runtime environments (including interpreters). The only thing assembly instructions actually care about is how many bits a binary value has and whether or not it should be stored as a floating point, integer, or pointer (I'm oversimplifying here but the point still stands). Assembly instructions only care about the data in the registers (or an address in memory) that they operate on.

There is no part of an interpreted language that requires it to not have any type-checking. In fact, many languages use runtime environments for better runtime type diagnostics (e.g. Java and C#) that couldn't be enforced at runtime in a purely compiled language like C or C++. Purely compiled binaries are pretty much the only environments where automatic runtime type checking can't be added without basically recreating a runtime environment in the binary (like what languages like go do). The only interpreter that can't have type-checking is your physical CPU.

If you meant that it is inherent to the language in that it was intended, you could make the case that for smaller-scale languages like bash, Lua, and some cases Python, that the dynamic typing makes it better. Working with large, complex frontends is not one of those cases. Even if this was an intentional feature of JavaScript, the existence of TypeScript at all proves it was a bad one.

However, while I recognize that can happen, I've literally never come across it in my time working on Typescript. I'm not sure what third party libraries you're relying on but the most popular OAuth libraries, ORMs, frontend component libraries, state management libraries, graphing libraries, etc. are all written in pure Typescript these days.

This next example doesn't directly return any, but is more ubiquitous than the admittedly niche libraries the code I work on depends on: Many HTTP request services in TypeScript will fill fields in as undefined if they're missing, even if the typing shouldn't allow for that because that type requirement doesn't actually exist at runtime. Languages like Kotlin, C#, and Rust would all error because the deserialization failed when something that shouldn't be considered nullable had an empty value. Java might also have options for this depending on the serialization library used.