Officially, Typescript made the decision not to include support for this type of traditional "old school" JavaScript syntax. They opted for the class syntax instead.

Nevertheless, it is possible to make it work by utilizing code from a previous answer provided by me:

// This section contains only instance members.
export interface Circle { // Naming the interface same as the variable.
  radius: number;
  area: () => number;
  perimeter: () => number;
}

// You can define static members here.
interface CircleConstructor {
  new(radius: number): Circle;
}

export const Circle = function(this: Circle, radius: number) {
  const pi = 3.14;
  this.radius = radius;
  this.area = function () {
    return pi * radius * radius
  }
  this.perimeter = function () {
    return 2 * pi * radius;
  }
} as unknown /*as any*/ as CircleConstructor; // Notice the casting
    
const c = new Circle(3); // works fine

There are some issues with this approach, such as the use of the any type which is not recommended, and the reliance on the as operator which can be considered unsightly. To address this, I have switched to using unknown instead of any, although the main problem remains. This adjustment prevents linting errors, making it an improvement over the usage of any.

So far, this is the most effective solution I have discovered. The developers of Typescript are aware of this issue but have chosen not to provide support for this type of "syntax".

If you have older JavaScript code that requires typing for TypeScript, you can generate definition files containing only types while keeping the runtime code in JavaScript.

For instance, a file.js file with an ES5 Foo class could have a corresponding file.d.ts with the following content:

// file.d.ts
export declare class Foo {
  x: number;
  y: number;
  constructor();
  set(): number;
}

// Any other TypeScript file
import { Foo } from 'any/path/file';
let foo = new Foo(); // Foo
const num = foo.set(); // number

The error in the question was moving the old JavaScript code to a TypeScript file instead of creating a separate definition file as TypeScript does not directly support ES5 syntax when defining classes.

Note: The constructor(); in this example is redundant since it's the implicit default constructor. However, you can define the constructor with any arguments or types and utilize multiple signatures using function overloads.

TypeScript playground

To answer the broader question of "how to type a constructible function not written as an ES6 class?", you can utilize the new keyword in TypeScript type or interface:

interface Foo {
  x: number;
  y: number;
  set(): number;
}

type Constructor<T> = new (...args: any[]) => T;

declare const newableFunction: Constructor<Foo>;

const obj = new newableFunction(); // Foo

TypeScript playground

In case the implementation is a simple function, it should ideally be placed in a separate JavaScript file to avoid mismatch errors between the declaration and implementation types during compilation.

Furthermore, consider a hybrid function that can be invoked with or without the new keyword:

// Function in 'file.js'
function newableFunction() {

  const self = Object.getPrototypeOf(this) === newableFunction.prototype ? this : {};

  self.x = 1;
  self.y = 2;
  self.get = function () {
    return self.x + self.y;
  }
  return self;
}

This unique function can be typed as follows:

interface Foo {
  x: number;
  y: number;
  get(): number;
}

interface Constructor<T> {
  (...args: any[]): T
  new (...args: any[]): T
}

export const newableFunction: Constructor<Foo>;

Example usage:

import { newableFunction } from './file';

const foo1 = newableFunction(); // Foo
const foo2 = new newableFunction(); // Foo

This kind of pattern can also be seen in native JavaScript types like the Number constructor in lib.es5.d.ts:

interface NumberConstructor {
    new(value?: any): Number;
    (value?: any): number;
    // ...

Add the following code in either a .d.ts or .ts file:

declare class Foo {
    public x: number;
    public y: number;

    set(): number;
}

Explore and test this code on Playground

In case you want to implement a similar scenario like this one, you can follow these steps - I will provide a more general example:

Imagine you have the following code snippet:

class Parent {
  constructor(name: string) {
    console.log(`Name is: ${name}`)
  }
  parent_method() { 
    console.log('Method in the parent class')
  }
}
class ChildOne extends Parent {
  constructor(name: string) {
    super(name)
  }
  child_one_method() {
    console.log('Child method in ChildOne class')
  }
}
class ChildTwo extends Parent {
  constructor(name: string) {
    super(name)
  }
  child_two_method() {
    console.log('Child method in ChildTwo class')
  }
}

type SomeConstructor<T extends Parent> = new (s: string)=> T

This approach allows you to create a function that initializes an instance for a generic type:

function initializer<T extends Parent>(ctor: SomeConstructor<T>, name: string) {
  return new ctor(name)
}

Instead of using fixed parameters as shown in the documentation example, here's a more flexible version of the generic initializer:

function fn_1(ctor: SomeConstructor<ChildOne>) {
  return new ctor("Child One");
}

Now, how do you use the initializer method? Here's an example of creating instances with specific parameter values:

const child_one = initializer(ChildOne, 'CHILD ONE')  // "Name is: CHILD ONE"
const child_two = initializer(ChildTwo, 'CHILD TWO')  // "Name is: CHILD TWO"

child_one.child_one_method()  // "Child method in ChildOne class"
child_two.child_two_method()  // "Child method in ChildTwo class" 
child_one.parent_method()  // "Method in the parent class" 

Note: This behavior resembles Java's Reflection, where you can instantiate any Generic Type with a specified parameter.

If you still prefer the implementation from the Docs, you can use this alternate method instead of initializer:

function fn_2(ctor: SomeConstructor<ChildTwo>) {
  return new ctor("Child Two");
}

And to utilize this method:

const two = fn_2(ChildTwo)  // "Name is: Child Two"
two.child_two_method()   //  "Child method in ChildTwo class" 

Important: This example is less generic compared to the previous one. Finally, you can test out this working example in the Playground