What is declaration merging? | Interview Question

Q: What is declaration merging?

**Target Audience:** Developers who have seen the same interface name declared twice, or `namespace` blocks next to a function, and want the rules. **Difficulty:** Medium **TypeScript version:** Every compiler message and output below was produced with TypeScript 5.4.5 (`--strict`, target ES2022). > **How to read this doc:** Each idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. All output was produced by actually running the code; the **Verified** section quotes it in full. This page covers the merging rules. Using them to extend a library from your own code is [module augmentation](/interview-question/what-is-module-augmentation), and merging is one of the deciding differences in [interface vs type](/interview-question/what-is-the-difference-between-interface-and-type). ## 1. Why This Even Matters — A Story First A school keeps one folder per student. The maths teacher adds a sheet with grade

The problem

Question presented to candidate: "TypeScript lets you write interface User twice and ends up with one type. What is declaration merging, which kinds of declarations can merge with which, and when is it useful or dangerous?"

What a strong answer should cover:

Declaration merging: the compiler combines several declarations with the same name (in the same scope) into one definition
Interface + interface: members are combined; a non-function member declared twice must have the identical type (TS2717); methods become overloads, with later declarations' signatures first and single-string-literal signatures bubbled to the top
Namespace merges with a function, class or enum (static members, nested types, helpers), and must come after the function or class (TS2434); enums merge with enums
What does not merge: type aliases (TS2300 Duplicate identifier) and classes with classes
Class + interface merging is unsafe: the interface adds members the class never implements, with no error; implements is the checked alternative
Real uses: extending global or library interfaces (Window, a library's options interface), which is the basis of module augmentation

Code / implementation expected: Optional — two interface declarations merging, and a function or class merged with a namespace.

interface-merging

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Developers who have seen the same interface name declared twice, or namespace blocks next to a function, and want the rules. Difficulty: Medium TypeScript version: Every compiler message and output below was produced with TypeScript 5.4.5 (--strict, target ES2022).

How to read this doc: Each idea is explained in plain language first, then tagged with 📌 Interview term: so you also learn the exact words an interviewer expects. All output was produced by actually running the code; the Verified section quotes it in full.

This page covers the merging rules. Using them to extend a library from your own code is module augmentation, and merging is one of the deciding differences in interface vs type.

1. Why This Even Matte

The solution is hidden so you can try first

10 min read · 11 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

TypeScriptThe merges that work

Practice

TypeScriptWhat does not merge, and the unsafe class + interface merge

Practice

Discussion

Other approaches, follow-ups and how it went in real interviews.

Sign in to join the discussion.

No comments yet. Share how you would answer it.

The solution is hidden so you can try first

Keep your momentum going.