TS2309: An export assignment cannot be used in a module with other exported elements

TypeScript has become a go-to language for millions of developers who want to write safer, more structured JavaScript. As a superset of JavaScript, it introduces features like strong typing, interfaces, enums, and more, making it an indispensable tool for building scalable and maintainable projects. But like any tool, TypeScript can sometimes throw errors that may seem cryptic or confusing, especially if you're new to its ecosystem. One such error is TS2309: An export assignment cannot be used in a module with other exported elements. In this article, we'll break down what this error means, why it happens, and how you can fix it.

If you're interested in mastering TypeScript or exploring AI-based tools like GPTeach to level up your coding skills, make sure to subscribe to our blog for ongoing tutorials, tips, and articles on TypeScript and beyond.

---

What is TypeScript and What are Types?

TypeScript is an open-source programming language developed by Microsoft. It's often called a "superset" of JavaScript because it builds on top of JavaScript by adding new features while still remaining compatible with standard JavaScript. This means any valid JavaScript code is also valid TypeScript code, but the reverse is not always true.

A key feature of TypeScript is its type system, which enables developers to explicitly define what kinds of values variables, functions, or properties can hold. Types are a mechanism for checking the validity of data at compile time (before the code runs), reducing runtime errors dramatically. Here's an example of how TypeScript leverages types:

let name: string = "TypeScript"; // 'name' can only hold string values
let age: number = 30; // 'age' can only hold numbers
let isDeveloper: boolean = true; // 'isDeveloper' can only hold true or false

By specifying the type explicitly, TypeScript ensures that if you try to assign the wrong value type to these variables—like assigning a boolean to name—the code will break during compilation instead of failing silently in runtime.

---

Important to Know!

TypeScript improves developer productivity and code reliability. However, with its power comes additional complexity and the possibility of dealing with tricky errors like TS2309: An export assignment cannot be used in a module with other exported elements. Understanding the basics—such as what types, interfaces, and other TypeScript constructs are—goes a long way in helping you resolve such issues.

---

Now that we’ve discussed TypeScript and types, let’s dive into the TS2309: An export assignment cannot be used in a module with other exported elements error.

---

TS2309: An export assignment cannot be used in a module with other exported elements

This error arises when you're working in a TypeScript environment and try to mix export = (an export assignment) with other named exports in the same file. These two export styles are incompatible, and TypeScript explicitly forbids their co-usage in a single module.

You might see this error in cases where you’re juggling different modules in a larger application, for example, combining CommonJS-style exports (module.exports) with ES module exports (export/export default). TypeScript enforces strict rules to keep your module system consistent and predictable.

Let’s break it down further with an example.

---

The Problem: Mixing Export Styles

Here’s a piece of code that would trigger the TS2309: An export assignment cannot be used in a module with other exported elements error:

// myModule.ts
export = MyClass;

class MyClass {
  hello() {
    console.log("Hello, TypeScript!");
  }
}

export const foo = 42;

In this case, the file uses export = to assign a value (MyClass) to the module, but it also includes a named export foo. This is not allowed in TypeScript.

---

Why Does This Happen?

The key reason this error occurs is that export = and named exports aren’t compatible:

• export = is part of a module system primarily designed for CommonJS, like what you’d find in Node.js. It allows you to "assign" a single object, function, or class to the entire module.
• Named exports (export or export default) are part of ES Modules (ECMAScript modules), introduced in modern JavaScript.

When TypeScript detects both in the same module, it throws the TS2309 error to prevent ambiguity.

---

How to Fix TS2309: An export assignment cannot be used in a module with other exported elements

The fix depends on how you want to structure your code. You can either:

1. Switch to only named exports.
2. Use export = and drop named exports.

Solution 1: Use Only Named Exports

If you’re using ES Modules and want to stick with named exports, you can refactor your code like so:

// myModule.ts
export class MyClass {
  hello() {
    console.log("Hello, TypeScript!");
  }
}

export const foo = 42;

This approach works seamlessly with modern ES6+ import/export syntax:

import { MyClass, foo } from "./myModule";

const myInstance = new MyClass();
myInstance.hello(); // Logs: "Hello, TypeScript!"
console.log(foo);   // Logs: 42

Solution 2: Use export = Exclusively

If your module is built to work with CommonJS instead of ES Modules, you can entirely drop the named exports:

// myModule.ts
class MyClass {
  hello() {
    console.log("Hello, TypeScript!");
  }
}

export = MyClass;

In this case, the export = syntax allows consumers of this module to import it like this:

const MyClass = require("./myModule");

const myInstance = new MyClass();
myInstance.hello(); // Logs: "Hello, TypeScript!"

Important to Know!

• If you're building a project for Node.js, the CommonJS module system (e.g., module.exports) is commonly used, and export = might suit your needs.
• If you're targeting browser environments or using modern JavaScript/TypeScript workflows, ES Modules (export/import) are the preferred way to go.

---

FAQ

1. Why does TypeScript care about my module system?

TypeScript enforces these restrictions to avoid potential runtime issues and maintain compatibility with corresponding JavaScript standards.

2. Can I use export = at all in modern TypeScript projects?

Yes, but export = is mostly used in projects that need to represent CommonJS-style exports, such as libraries designed for Node.js.

3. How do I know I’m mixing export styles?

If you’re using export = or relying on a package that uses module.exports, check your file for instances of additional named exports (export or export default). Remove one or the other to ensure consistency.

---

Conclusion

The TS2309: An export assignment cannot be used in a module with other exported elements error can initially seem confusing, especially if you're new to TypeScript or juggling different module systems. The key to resolving it lies in understanding the incompatibility between export = and other named exports in the same file.

By structuring your modules consistently, you can avoid running into this issue altogether. Stick to either ES module-style exports (export/export default) or CommonJS-style exports (export =), depending on your project's needs. For more articles, tips, and guides on mastering TypeScript, don’t forget to subscribe to our blog!