> ## 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 Ambient Enum
An ambient enum is a type declaration used to describe an enumeration that already exists at runtime, typically defined by an external script or a separate compilation process. By prefixing the `enum` keyword with `declare`, you instruct the TypeScript compiler to recognize the enum's shape and members for type-checking purposes without emitting any corresponding JavaScript code.
```typescript theme={"dark"}
declare enum ProcessState {
Idle,
Running,
Terminated
}
```
## Technical Mechanics
**Zero JavaScript Emission**
The primary mechanical difference between a standard enum and an ambient enum is the compilation output. A standard enum generates an Immediately Invoked Function Expression (IIFE) in JavaScript to create a runtime mapping object. An ambient enum generates absolutely zero JavaScript. The compiler assumes the object will be present in the global scope at runtime.
**Member Initialization and Computed Values**
TypeScript enforces a strict distinction in how it evaluates uninitialized members between standard enums and non-const ambient enums:
* In a **standard enum**, a member without an initializer is considered *constant* (automatically assigned an incrementing numeric value).
* In a **non-const ambient enum** (`declare enum`), a member without an initializer is always considered *computed*. The compiler acknowledges the member exists but does not infer a numeric value for it.
```typescript theme={"dark"}
// Standard Enum: 'A' is constant (0), 'B' is constant (1)
enum StandardEnum { A, B }
// Ambient Enum: 'X' and 'Y' are computed. Their underlying values are unknown to the compiler.
declare enum AmbientEnum { X, Y }
```
## Ambient Const Enums
Applying the `const` modifier to an ambient enum (`declare const enum`) alters the compiler's behavior regarding both member initialization and how the enum is consumed at the call site.
Unlike a standard ambient enum, an ambient `const` enum treats uninitialized members as *constant*, automatically inferring incrementing numeric values starting at `0` (or incrementing from the previous explicit numeric value).
Furthermore, while a standard ambient enum leaves property access intact in the emitted JavaScript (expecting the object to exist at runtime), an ambient `const` enum forces the compiler to inline the actual resolved values directly into the emitted JavaScript.
```typescript theme={"dark"}
declare const enum StatusCode {
Success = 200,
NotFound = 404,
Unknown // Inferred as constant 405
}
declare const enum Direction {
Up, // Inferred as constant 0
Down // Inferred as constant 1
}
// Usage
let code = StatusCode.Success;
let dir = Direction.Up;
let state = ProcessState.Running; // From the non-const declare enum above
```
**Compiled JavaScript Output:**
```javascript theme={"dark"}
// The ambient const enum values are inlined directly.
let code = 200;
let dir = 0;
// The standard ambient enum retains the object property access.
let state = ProcessState.Running;
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
