How do I type module.exports and require() in CommonJS JavaScript?

The short answer

Write CommonJS as usual: JSDoc on the functions, module.exports = { … } at the end. tsc reads the exported object as the module’s exports:

/**
 * @param {number} cents
 * @returns {string}
 */
function formatPrice(cents) {
  return `$${(cents / 100).toFixed(2)}`;
}

/** @typedef {{ sku: string, cents: number }} PriceTag */

/** @param {PriceTag} tag */
function describeTag(tag) {
  return `${tag.sku}: ${formatPrice(tag.cents)}`;
}

module.exports = { formatPrice, describeTag };

export function formatPrice(cents: number): string {
  return `$${(cents / 100).toFixed(2)}`;
}

export type PriceTag = { sku: string; cents: number };

export function describeTag(tag: PriceTag): string {
  return `${tag.sku}: ${formatPrice(tag.cents)}`;
}

require() in another file then returns those functions with their types, and a @typedef in a CommonJS file is exported too, so import("./price.cjs").PriceTag names it:

const { formatPrice, describeTag } = require("./price.cjs");

/** @type {import("./price.cjs").PriceTag} */
const lamp = { sku: "LAMP-01", cents: 3900 };

console.log(formatPrice(1999), describeTag(lamp));

Why it works

TypeScript understands the CommonJS patterns Node.js uses: module.exports = …, exports.name = … and const { … } = require("./file.cjs"). With @types/node installed, require is declared, and tsc resolves the path and types the result from the other file’s JSDoc. Every top-level @typedef of a module is part of its exports, whatever module syntax the file uses.

The same module as an ES module is the shape most new code takes; the checking is identical:

import { formatPrice, describeTag } from "./price.js";

/** @import { PriceTag } from "./price.js" */

/** @type {PriceTag} */
const lamp = { sku: "LAMP-01", cents: 3900 };

console.log(formatPrice(1999), describeTag(lamp));

The same thing in TypeScript

The TypeScript equivalent tab of the first example is a .cts file. TypeScript writes CommonJS with export syntax and turns each export function into an exports.formatPrice = … assignment when it compiles; export = is the closer match to module.exports = { … }, but it cannot sit beside an exported type. JavaScript has no such restriction: the @typedef is exported alongside module.exports.

What goes wrong

Destructuring a name the module does not export is TS2305, and the required functions are checked like local ones, so a string where formatPrice wants a number is TS2345:

const { formatCost } = require("./price.cjs");error TS2305: Module '"./price.cjs"' has no exported member 'formatCost'.
const { formatPrice } = require("./price.cjs");

console.log(formatPrice("19.99"), formatCost);error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

Gotchas

• require needs @types/node. Without it, require is an unknown name (TS2580, or TS2591 when the config has a types list). Install @types/node and list "node" in types if the config has a types list.
• exports.name = … works too. Assigning properties one by one (exports.addTax = (cents) => …) declares the same named exports, typed from each value.
• tsc does not catch mixed module syntax. TypeScript 5.9 accepts import statements in a .cjs file and module.exports in a .mjs file without an error, but Node.js refuses both when the file runs. Keep one syntax per file.