“该类型上不应存在成员”的 TypeScript 类型声明？

Question

Is there a way in a TypeScript record type to assert that the type must not contain a property with a particular name?

The use case is where we're using the presence of a particular property at runtime to tell the difference between an object that implements a particular interface vs. a property bag for specifying named arguments.

For example: TS playground link

interface Foo {
  readonly bar: string;
}
function f(arg: Foo | {foo: Foo}) {
  // get a Foo instance, either as the argument or as a named arg
  const foo: Foo = 'foo' in arg ? arg.foo : arg;
  return foo.bar;
}

We'd like to warn implementers of the Foo interface that they must not have a property called foo on their type. For example, we'd like this code to cause a compile error:

class MyFoo1 implements Foo {
  foo: Foo = { get bar() { return 'abc'; } }; // wanted: compile error here
  get bar() { return this.foo.bar; }
}
class MyFoo2 implements Foo {
  foo: string = 'bar'; // wanted: compile error here
  get bar() { return this.foo; }
}
// no compiler errors expected from this class
class MyFoo3 implements Foo {
  get bar() { return 'hello'; }
}

Can we do this?

The possible solutions I've considered are:

1. never - This one will produce an error, but it also claims that this property actually exists, which seems wrong.

interface Foo {
  foo: never;
  bar: string;
}

2. undefined - This seems closer to what we want, but won't it still show up in IDE autocomplete when it never exists?

interface Foo {
  foo?: undefined;
  bar: string;
}

3. conditional type - This one seems the most promising, but I'm not sure how to make a non-generic conditional type so that callers could say class MyFoo2 implements Foo not class MyFoo2 implements Foo<SomethingElse> .

Answer 1

The trick you want is:

interface Foo {
  foo?: never
  readonly bar: string;
}

This tells typescript that foo either must be omitted, or it must have a type of never , which is never allowed. This reduces to just the fact that it must be omitted.

Playground

---

Note that I did have to change your runtime code a tiny bit to get this to compile.

const aFoo: Foo = ('foo' in arg && arg.foo) ? arg.foo : arg;

Typescript wasn't quite smart enough to infer that the branch of the union there, because it's hard to tell the difference at runtime from an omitted prop and a prop with a value of undefined . By forcing it to check that arg.foo has a truthy value it then knows that arg must be of type { foo: Foo } .