TypeScript Module Augmentation: Extend Third-Party Types (2026)

Module augmentation lets you add properties or methods to existing types from third-party libraries without modifying their source code.

Let’s see it in action. Imagine you’re using a popular utility library, lodash, and you want to add a custom method to its string object.

// First, we need to declare that we're augmenting the lodash module.
// This is done by declaring a namespace with the same name as the module.
declare namespace lodash {
  // Inside this namespace, we declare the interface we want to extend.
  // In this case, it's the string object within lodash.
  interface StringFunctions {
    // Now, we add our custom method signature.
    // It takes a string and returns a string.
    reverseString(input: string): string;
  }
}

// Now, we can implement this augmented functionality.
// This implementation code is separate from the type declaration.
// It's often placed in a separate file, perhaps named `lodash.extensions.ts`.
import * as _ from 'lodash';

_.string.reverseString = (input: string): string => {
  return input.split('').reverse().join('');
};

// And now we can use it as if it were part of the original library.
const originalString = "hello";
const reversedString = _.string.reverseString(originalString);
console.log(reversedString); // Output: olleh

The problem this solves is the common scenario where you need to integrate third-party code into your application but find its type definitions lacking for your specific use cases. You can’t just extend the library’s classes directly because you don’t own the source. Module augmentation provides a type-safe way to "monkey patch" the types of external modules.

Internally, TypeScript’s module resolution and type checking work together. When you declare namespace lodash { ... }, you’re telling the TypeScript compiler, "Hey, there’s a module named lodash, and I want to add some things to its global scope." The interface StringFunctions part then specifies what you’re adding to. When you later import * as _ from 'lodash', TypeScript merges your declarations with the library’s original types, making your augmented members available.

The exact levers you control are the module name you declare namespace on, and the specific interfaces or types within that module you choose to extend. You can add new methods, properties, or even entirely new types that become part of the module’s exported shape.

A common pitfall is forgetting to implement the functionality you’ve declared. The type declaration declare namespace lodash { ... } only tells TypeScript that the member should exist. It doesn’t create it. You still need to write the actual JavaScript code that provides the implementation, typically in a separate file, and ensure it’s imported or included in your project’s compilation. If you declare a method but don’t implement it, your code will compile fine, but you’ll get a runtime error when you try to call the non-existent function.

This technique is also crucial for augmenting ambient modules (those declared with declare module 'module-name' { ... }) or even built-in JavaScript objects if you’re careful.

The next hurdle you’ll face is understanding how to handle default exports and named exports from third-party modules when augmenting them.