What is declaration merging, and are namespaces still used?

A declaration creates a namespace, a type, a value, or a mix (Handbook table: a class makes type and value, an interface only a type, a namespace makes namespace and value). When two declarations with the same name create compatible meanings, TypeScript merges them.

• Interface + interface (the common case): members join into one interface. Function members become overloads, later declarations first. Non-function members with the same name must have the same type, else TS2717.
• Namespace + namespace: exported members are combined. Non-exported members are visible only to the block that declared them, so the second block cannot see them (TS2304).
• Namespace + function / class / enum (the namespace comes after): adds properties to the function, inner types or statics to the class, or helper functions to the enum. This is the only way to type a callable-with-properties built in plain JavaScript.
• Interface + class merges too, which types members the class does not initialise.
• Do not merge: type aliases, class + class, class + variable (duplicate identifier, TS2300).
• Module augmentation (declare module "./x", declare global) is merging across files: it patches existing declarations only.

Are namespaces still used? Not to organise application code: a file is already a module and the importer names it, so wrapping exports in a namespace is "needless namespacing" (Handbook). They remain for declare namespace in global/UMD typings, for function and enum merging, and in older codebases. A namespace containing values emits an IIFE, so it is runtime code, and erasableSyntaxOnly rejects it (TS1294). Type-only and declare namespaces are still allowed.

// TypeScript 7.0.2 and 5.9.3, --strict
interface Box { height: number }
interface Box { width: number }
const box: Box = { height: 1, width: 2 }; // one merged interface, no emitted code

interface Config { port: number }
interface Config { port: string }
// Error TS2717: Subsequent property declarations must have the same type.  Property 'port' must be of type 'number', but here has type 'string'.

function buildLabel(name: string) { return buildLabel.prefix + name; }
namespace buildLabel { export let prefix = "Hello, "; } // adds a property to the function

namespace Animal {
  let hidden = true;
  export function a() { return hidden; }
}
namespace Animal {
  export function b() { return hidden; }
  // Error TS2304: Cannot find name 'hidden'.
}
console.log(buildLabel("Sam"), Animal.a(), box.width);
// → Hello, Sam true 2

• Assuming a merged interface Foo on a class Foo creates the property. interface Foo { extra: number } class Foo {} compiles and f.extra is typed number, but nothing assigns it, so the value is undefined at runtime.
• Expecting type to merge. A type T and an interface T of the same name give Duplicate identifier 'T' on both compilers; this is the practical reason libraries expose interfaces that users can augment.
• Declaring the namespace before the function/class/enum it should merge with. The Handbook requires the namespace to follow it.
• Reaching for namespace to group related exports in a module file, which forces consumers to write shapes.Shapes.Triangle.