The compiler allows the forward declaration of a type name only. The type name then can be used as a reference or a pointer only. If we want to call a method of this type, a complete type definition is required. I understand that this requirement comes from the storage details. But this compiler's restriction is unnecessery for static and non-virtual methods, and other things that are not related to the instance data.

A programmer just wants to tell the compiler that the class/struct will have a method named X with parameters Y. Why is it problematic to the compiler? The same is about class constants and enums.
A partial definition of type methods, constants and enums improves the readability of the code, hides implementation details, and speeds up compilation.

Hiding implementation details in C++ is done today either with PIMPL or interface definition. Interfaces are closest to the partial type definition, but still their main purpose is an abstract interface implemented by several different classes. If there is only one class, then placing its public methods into the interface is an unnecessary overcomplication. I propose a partial class definition that simplifies and allows to have only one type name.

The 'extern' declaration of class only without variable name can be used for partial type definition:

// .h file 
extern struct worker
{
  void work();
};

inline void do_work(worker& w)
{
  w.work();
}
// .cpp file
struct worker
{
  void work(); // optional declaration
private:
  int x=0;
};

void worker::work() 
{
  x++;
}