Is there a way to add correct type annotations for this TypeScript code with an inline function class?

What type annotations can I add to inform TypeScript that this code is correct?

Yes I do need that inline function class. This code has been reduced from my actual problem to this simplified version.

let x = 10;
const obj = new (function() {
  if(--x) return this.constructor();
  return {};
});

'this' implicitly has type 'any' because it does not have a type annotation.ts(2683)
'new' expression, whose target lacks a construct signature, implicitly has an 'any' type.ts(7009)

I tried totally annotating everything and that doesn't fix it. Here is what that looks like:

type myType = { constructor(): myType };
let x: number = 10;
const obj: myType = new (function(): myType {
  if(--x) return (this as myType).constructor();
  return {} as myType;
});

'new' expression, whose target lacks a construct signature, implicitly has an 'any' type.ts(7009)

Is there something in the TypeScript docs I'm missing? There don't seem to be any Constructor types that are generic and the Constructor types don't really appear to be for constructors.

If you want to say that a type is "newable", or a valid target for the new operator, you should use a construct signature. A construct signature can be written either as { new (⋯): ⋯} like a call signature or as new (⋯) => ⋯ like an arrow function expression.

Here's one way to write your code so it compiles:

let x = 10;
type MyType = { new(): {} };
const obj = new ((function (this: {}) {
  console.log(x);
  if (--x) return this.constructor();
  return {};
}) as any as MyType);

Here we've defined MyType as { new(): {} }, a construct signature that takes no constructor arguments and produces a value of type {}.

Then we've asserted that the anonymous function expression is of type MyType via (⋯) as any as MyType. Note that (⋯) as MyType fails because TypeScript doesn't see callable types and newable types as related enough to allow direct assertions between them. (In modern JavaScript, most class constructors will complain if you try to call them without new, and arrow functions complain if you try to new them instead of calling them, so TypeScript separates these on purpose.) You need something intermediate that is seen as related to both; I chose the any type but you could something else, like Function for example.

Also I gave the anonymous function a this parameter of type {}, so that the compiler would be happy manipulating this inside the function body.

Anyway, now there is no error, and the value of obj is inferred as being of type {}. Obviously in your actual use case you'll need to figure out the typings that meet your needs, but presumably whatever those are they will involve at least one construct signature.

Playground link to code

Make a generic to map it from (...a: A) => B type to new (...a: A) => B

function fakeNewable<F extends (...a: any) => any>(
  fn: F,
): (new (...a: Parameters<F>) => ReturnType<F>) /* ` & F` if you also need other props */ {
  return fn as any
} 
function foo() {
  return Math.random() > 0.5 ? 'foo' : { foo: 'bar' };
}
let v = new (fakeNewable(foo))
//  ^?
// let v: string | { foo: string; }

(remember, that if you return undefined inside new call, you'll get the constructed object)