> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript Import Equals
The `import ... =` syntax in TypeScript is a module and namespace aliasing mechanism. It is utilized to bind a local identifier to an external CommonJS/AMD module via `require()`, or to create a shorthand reference for deeply nested internal namespaces, classes, or enums.
This syntax operates differently from ECMAScript 6 (ES6) standard imports (`import ... from ...`) and is specifically tied to TypeScript's module resolution and type-checking phases.
## External Module Import (`require`)
When interfacing with CommonJS or AMD modules, TypeScript uses `import = require()` to import modules that are exported using TypeScript's specific `export =` syntax.
```typescript theme={"dark"}
// Syntax
import alias = require("module-name");
// Example
import express = require("express");
```
**Mechanics:**
* **Type Preservation:** Unlike a standard JavaScript `const express = require("express")`, the `import = require()` syntax imports both the runtime value and the associated TypeScript type definitions.
* **Emission:** When the TypeScript compiler (`tsc`) targets CommonJS, this syntax transpiles directly into a standard Node.js `require()` call: `const express = require("express");`.
## Internal Namespace Aliasing
The `import =` syntax is also used to create local aliases for symbols defined within TypeScript `namespace` blocks.
```typescript theme={"dark"}
namespace Application {
export namespace Infrastructure {
export class DatabaseConnection {
connect() {}
}
}
}
// Syntax
import alias = Namespace.NestedNamespace.Symbol;
// Example
import DbConn = Application.Infrastructure.DatabaseConnection;
const conn = new DbConn();
```
**Mechanics:**
* **Dual Binding:** The alias created by `import =` binds to both the *type* and the *value* of the referenced entity. You can use the alias in type annotations (`let x: DbConn`) or as a runtime value (`new DbConn()`).
* **Type Erasure:** TypeScript applies strict type erasure to namespace aliases. If the alias is used *only* in type positions (e.g., as an interface or type annotation), the compiler completely removes the `import =` statement from the emitted JavaScript.
* **Value Emission:** If the alias is used as a runtime value, the compiler emits a standard `var` assignment in the resulting JavaScript to maintain the reference:
```javascript theme={"dark"}
// Emitted JavaScript
var DbConn = Application.Infrastructure.DatabaseConnection;
var conn = new DbConn();
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
