Answer.

Background:

Static properties and methods appeared in JavaScript classes starting from ES6; however, strict typing of these elements became possible thanks to TypeScript. In dynamic JavaScript, class static elements do not differ in type from instance elements, but TypeScript allows adding type safety and class structure considering static members.

Problem:

Static properties and methods belong to the class itself, not to its instances. However, many developers confuse the typing of an instance (through this or constructor) with the typing of the class itself as an object. This sometimes leads to errors when accessing static fields within methods or when inheritance occurs.

Solution:

In TypeScript, static members of classes are typed separately from instance members:

Instance members are described through the class body.
Static members are described using the static keyword.
The type of the class itself can be described using the typeof construct to safely pass and use it as an object with a defined structure.

Code example:

class User {
  static count: number = 0;

  name: string;
  constructor(name: string) {
    this.name = name;
    User.count++;
  }

  static getCount(): number {
    return User.count;
  }
}

function createUserClass(): typeof User {
  return User;
}

Key features:

Static members reside not in the instance but in the class constructor, thus they are only accessible through the class itself.
To pass/type the class itself, typeof User is used, while for instances, User is utilized.
Static methods have their own limitations (no access to this unless invoked through the class constructor).

Trick questions.

Can static methods work with instance properties of the class directly?

No, static methods do not have access to instance properties via this, as this points to the class itself (the constructor). To work with instance properties, one must work with object instances.

class Demo {
  static demoStatic() {
    // this.value; // Error — value is not static
  }
}

Can a static property be accessed through an instance of the class?

No, access to static properties is only possible through the class name itself, not through an instance:

const u = new User('Max');
console.log(u.count); // Error
console.log(User.count); // OK

Can static methods be inherited and overridden when inheriting a class?

Yes, static methods can be inherited and overridden, and it will work as expected:

class Animal {
  static who() { return 'Animal'; }
}
class Dog extends Animal {
  static who() { return 'Dog'; }
}
console.log(Dog.who()); // 'Dog'

Common mistakes and anti-patterns

Confusion between static and instance members of the class
Attempt to access static fields through an instance
Errors when using this inside static methods

Real-life example

Negative case

A developer stores a counter of created instances as a regular instance property instead of as static. With each object creation, the field increases, but it is not synchronized across all class objects.

Pros:

Simple to implement without knowledge of static

Cons:

Violation of invariants, the counter does not reflect the number of objects, potential errors during mass creation

Positive case

Using static count to account for all objects, correctly increasing it in the constructor and a static method for retrieving the counter.