No way to type an object with null prototype

Currently the base type of all objects in TS seems to be {}, which looks like an empty type but actually has members inherited from the Object object. This leaves no way to express a type with null prototype.

var foo: ??? = Object.create(null);
foo.toString(); // Want a compile error here

I did accidentally discover that it’s possible to type a variable as void:

var foo: void = Object.create(null);

This appears to suppress intellisense for members in VS and the playground, and it is assignable to any (Object.keys(foo) compiles), so it would seem to be what I’m looking for. However this still lets foo.toString() compile somehow - I imagine the void type is getting elevated to Object automatically.

Edit: Ryan’s workaround to subtype Object and override all its members to void prevents those properties from being called as functions, but as he points out, that doesn’t prevent them from being accessed.

var bar = foo.toString; // Want a compiler error here too. Won't get one with Ryan's workaround.

[KilianKilmister]

If i’m looking to create a large inheritance structure, I prefer them to start on a null-prototype, It inherently protects them from possible prototype polution on the Object.prototype and as I basically never need to support the legacy Object.prototype methods, there is no real downside.

The lack of a proper Null object type in TS has made me use it less, and i dislike that.

[texastoland]

We are not really looking for a formal proposal, just a formulation for what changes would be needed to implement, and what impact this has on other parts of the type system.

@mhegazy @RyanCavanaugh what would you think about just changing lib.d.ts like below?

namespace Object {
  export type NullPrototype = Record<keyof Object, never>
}

interface ObjectConstructor {
  create
    <T extends object | null>
    (proto: T):
    T extends null ? Object.NullPrototype : T
}

Playground

interface IDictLike<T> {[key: string]: T}
type DictLike = IDictLike<string> & Object.NullPrototype
const dictLike: DictLike = Object.create(null)

console.log(dictLike.key)
console.log(dictLike.toString())
//          ^^^^^^^^^^^^^^^^^^^
// Cannot invoke an expression whose type lacks a call signature.
// Type 'never' has no compatible call signatures.

// Same type as Object.create(Array.prototype)
const arrayLike = Object.create([])
console.log(arrayLike.key)
//                    ^^^
// Property 'key' does not exist on type 'any[]'. Did you mean 'keys'?
console.log(arrayLike.toString())