Is it possible to reference an implementing type in an abstract class method type in TypeScript?

I have an abstract class Thingydoo, and a class Thingymabob that extends it. I have some static methods on Thingydoo that I want to create something of a type that exists in Thingymabob. The underlying reason I'm trying to do this is in order to give an API for different types of Thingydoo to be created with different options for each of them programmatically.

interface MyStuff {
    [name: string]: {someParam: string}
};

type Something<T> = {
    thing: T;
}

abstract class Thingydoo {
    //                  here - on this line - TypeScript uses "this" to mean Thingydoo, not the Thingymabob that comes from it
    static testWithTypeParam(thing: ReturnType<typeof this.differentFunc>): Something<ReturnType<typeof this.differentFunc>> {
        // here, in this line, TypeScript _knows_ that this.name is Thingymabob, not Thingydoo.
        console.log("hi! this is a " + this.name);
        return {thing: thing};
    }

    static differentFunc() : MyStuff {
        return {};
    }
}

class Thingymabob extends Thingydoo {
    static differentFunc(): {beans: {someParam: string}} {
        return {beans: {someParam: "test"}};
    }

    static feedMeBeans(beansContainer: {beans: {someParam: string}}) {
        console.log(beansContainer.beans.someParam);
    }
}

let something = Thingymabob.testWithTypeParam({beans: {someParam: "test3"}});
// so this, despite making sense and compiling to JS fine + running fine in JS, issues a compiler error in tsc, because it doesn't realise the beans type is MyStuff compatible.
Thingymabob.feedMeBeans(something.thing);

In this example, I want testWithTypeParam to return an object of type {beans: {someParam: string}}, so as to be compatible with the feedMeBeans method on Thingymabob. This doesn't seem to want to be possible at all, though: I can't find a way of doing it. I've tried using the polymorphic this types, as shown in the example code, but have made no headway at all with that route: it seems to make absolutely no difference (playground).

Am I missing something obvious?

TypeScript doesn't directly support the polymorphic this type for static members. There's a longstanding open feature request for it at microsoft/TypeScript#5863, but it hasn't been implemented (yet?). Until and unless that happens you'll have to work around it.

For static methods a common workaround is to make the method generic in a type T constrained to some supertype of what you want this to be (it might be typeof Foo if your class name is Foo, but it doesn't have to be), and then give the method a this parameter of type T. And then (in this might be the part you were missing) you use the type T in place of the type this. So instead of

class Foo { 
  ⋯
  static method(arg: A<this>): R<this> {⋯} 
  ⋯
}

you'd have

class Foo { 
  ⋯
  static method<T extends typeof Foo>(this: T, arg: F<T>): R<T> {⋯} 
  ⋯
}

For your code that looks like

abstract class Thingydoo {
    
    static testWithTypeParam<T extends typeof Thingydoo>(
        this: T, thing: ReturnType<T["differentFunc"]>
    ): Something<ReturnType<T["differentFunc"]>> {
        console.log("hi! this is a " + this.name);
        return { thing: thing };
    }

    static differentFunc(): MyStuff {
        return {};
    }
}

Note that T is a type, not a value, so you can't write typeof T.differentFunc. Instead you want "the type of the property of T whose key is "differentFunc"", which you get via the indexed access type T["differentFunc"].

And now it works as desired:

let something = Thingymabob.testWithTypeParam({ beans: { someParam: "test3" } });
// let something: Something<{ beans: { someParam: string; }; }>
Thingymabob.feedMeBeans(something.thing); // okay

Playground link to code