How to fix Cannot use 'new' with an expression whose type lacks a construct signature in TypeScript

function Employee(fullName: string, salary: number) {
  this.fullName = fullName;
  this.salary = salary;
}

// TS2351 Error here:
const emp1 = new Employee('Bobby Hadz', 100);

class Employee {
  constructor(
    public fullName: string,
    public salary: number,
  ) {}

  getSalary() {
    return this.salary;
  }
}

// Works correctly:
const emp1 = new Employee('Bobby Hadz', 100);

function Employee(this: any, fullName: string, salary: number) {
  this.fullName = fullName;
  this.salary = salary;
  this.getSalary = function () {
    return this.salary;
  };
}

// Still requires type assertion:
const emp1 = new (Employee as any)('Bobby Hadz', 100);

interface EmployeeConstructor {
  new (fullName: string, salary: number): Employee;
}

interface Employee {
  fullName: string;
  salary: number;
  getSalary(): number;
}

function Employee(this: Employee, fullName: string, salary: number) {
  this.fullName = fullName;
  this.salary = salary;
}

Employee.prototype.getSalary = function () {
  return this.salary;
};

// Type the variable as the constructor interface:
const EmployeeConstructor: EmployeeConstructor = Employee as any;
const emp1 = new EmployeeConstructor('Bobby Hadz', 100);

// Wrong - NextResponse.json() is not a constructor:
return new NextResponse.json({ message: 'Hello' });

// Correct - call it as a regular function:
return NextResponse.json({ message: 'Hello' });

// Define what 'new' should do with this function
type Constructor = new (name: string) => { name: string };

// This function matches the Constructor type:
function MyClass(this: { name: string }, name: string) {
  this.name = name;
}

// Use with proper typing:
const MyClassConstructor: Constructor = MyClass as any;
const instance = new MyClassConstructor('test');

// Define both static and instance types
interface MyClassStatic {
  new (): MyClassInstance;
}

interface MyClassInstance {
  method(): void;
}

// Declare the variable with the static interface:
declare const MyClass: MyClassStatic;
const instance = new MyClass();

async function loadPlugin(pluginName: string) {
  const module = await import(`./plugins/${pluginName}`);

  // Type assert as a constructor
  type AnyConstructor = new (...args: any[]) => any;
  const PluginClass = module.default as AnyConstructor;

  // Now 'new' works without error:
  const instance = new PluginClass();
  return instance;
}

import { someValue } from 'some-library';

// If someValue should be constructable, assert it:
type Constructable<T> = new (...args: any[]) => T;
const Constructor = someValue as Constructable<MyType>;

const instance = new Constructor();

# For popular libraries, @types packages provide TypeScript definitions
npm install --save-dev @types/some-library

// Wrong - importing the namespace instead of the class:
import * as MyClass from './MyClass';
const instance = new MyClass(); // Error

// Correct - import the class directly:
import MyClass from './MyClass';
const instance = new MyClass(); // OK

// Look at the .d.ts file or source to verify it exports a class/constructor
// For example, in node_modules/@types/some-lib/index.d.ts:

// If it's exported as class:
export class SomeClass { }

// If it's exported as namespace:
export namespace SomeClass { }

// The second case won't work with 'new'

{
  "compilerOptions": {
    // Enable strict mode for better type safety
    "strict": true,

    // More granular strict options:
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": true,
    "noImplicitAny": true,
    "noImplicitThis": true,

    // Helps catch constructor issues:
    "noImplicitReturns": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,

    // Module resolution:
    "moduleResolution": "node",
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}