Skip to main content

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.

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. 
// 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. 
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:
// Emitted JavaScript
var DbConn = Application.Infrastructure.DatabaseConnection;
var conn = new DbConn();
Master TypeScript with Deep Grasping Methodology!Learn More