Should you use enums or union types?

An enum is not a type-level extension of JavaScript (the Handbook says so): it declares both a type and a runtime object.

• Numeric enum emits E[E["A"] = 0] = "A", an object with a forward map and a reverse mapping (E[0] === "A"). That is why Object.keys on it returns both names and numbers. String enums emit only the forward map.
• Enum types are not their literals. Since 5.0 every enum is a union of its member types and an out-of-domain literal is an error, and a string enum rejects the matching plain string: const c: Color = "RED" fails. Any plain number is still assignable to a numeric enum.
• const enum is erased and its members are inlined at use sites. The Handbook warns this breaks across packages (ambient const enums) and isolatedModules rejects ambient ones.
• Union of literals (type Status = "active" | "banned") emits nothing, accepts plain strings, and narrows and exhausts well. If you also need the values at runtime, use an as const object plus typeof Obj[keyof typeof Obj].

My default: a string union, or an as const object when I need to iterate or reference the values. The Handbook itself presents the as const object as often sufficient, since it stays plain JavaScript. I reach for an enum for numeric bit flags with computed members, or when the codebase already uses them. If the project sets erasableSyntaxOnly (for Node type stripping) enums are not allowed at all.

Tradeoff: an enum gives a nominal-ish, namespaced type and autocompletion on Role.Admin; a union gives interop (JSON, plain strings, other packages) without conversion.

// TypeScript 7.0.2 and 5.9.3, --strict
enum Role { Admin, User }
enum Color { Red = "RED" }
const Status = { Active: "active", Banned: "banned" } as const;
type Status = (typeof Status)[keyof typeof Status]; // "active" | "banned"

function setStatus(s: Status) { console.log(s); }
setStatus(Status.Active);
setStatus("banned"); // OK: a plain literal is a valid Status
setStatus("gone");
// Error TS2345: Argument of type '"gone"' is not assignable to parameter of type 'Status'.

const r: Role = 5;
// Error TS2322: Type '5' is not assignable to type 'Role'.
const c: Color = "RED";
// Error TS2322: Type '"RED"' is not assignable to type 'Color'.
const n: number = Role.User;
const ok: Role = n; // OK: any `number` is assignable to a numeric enum

console.log(Object.keys(Role), Object.values(Status));
// → [ '0', '1', 'Admin', 'User' ] [ 'active', 'banned' ]

• Passing a string literal to a string-enum parameter. It fails (Type '"RED"' is not assignable to type 'Color'), so values from JSON or an API need a cast or a validator.
• Iterating a numeric enum with Object.keys/Object.values and getting the reverse-mapping entries too ([ '0', '1', 'Admin', 'User' ]). String enums and as const objects do not have this.
• Treating numeric enums as closed. Literals outside the domain are an error (5.0+), but const ok: Role = n with a number compiles, so an arbitrary value can still reach a Role.
• Using const enum in a published library. Consumers inline your values at their compile time and can disagree with the runtime version; isolatedModules also rejects ambient ones (TS2748).