About the console on this page. It compiles one file, so import statements have nothing to resolve and the import snippets below are shown rather than run. Everything in the runnable blocks further down is real, compiled and executed.

Module or script

One top-level import or export makes the file a module. Without either, every declaration is global, so two files declaring const config collide. The conventional fix in a file with nothing to export is a bare export {} at the bottom.

Named, default and namespace imports

import { createUser } from "./user";        // named — the one to prefer
import createUser from "./user";            // default — any local name allowed
import * as user from "./user";             // namespace — the whole module object
import "./register";                        // side effect only

Prefer named exports: they are what tree shaking and rename refactoring both rely on, and a default export can be imported under any name, which makes it harder to grep for.

Type-only imports

import type { User } from "./user";         // erased entirely from the output
import { type User, createUser } from "./user";   // mixed, inline form

It matters because a plain import of something used only as a type is also removed — silently — and if that module had a side effect, the side effect disappears with it. Being explicit removes the guesswork, and verbatimModuleSyntax makes it mandatory.

Import elision, and the bug it causes

TypeScript removes imports whose bindings are never used as values. That is why importing a module purely for its decorators or its global registration can vanish in production. The cure is either a side-effect import — import "./register", never elided — or verbatimModuleSyntax, which stops the compiler guessing.

Namespaces are not modules

namespace predates ES modules and exists mainly for declaration files describing global libraries. In application code a file plus an export does the same job better: a namespace creates a real object at runtime, and you can see that in the runnable block below.