TypeScript Index Signatures vs Mapped Types with Enums

By the end of this page, you will understand why TypeScript index signatures only work with broad key types like string, number, or symbol, and why enum-based key sets must use mapped types instead. You will also learn how to use Record, how mapped types enforce exact keys, and how to avoid common mistakes when typing objects with enum or union keys.

In TypeScript, an index signature describes objects whose keys are not known exactly ahead of time, but follow a broad category such as:

[key: string]: ValueType

That means any string key is allowed.

Your enum:

enum Option {
  ONE = 'one',
  TWO = 'two',
  THREE = 'three'
}

represents a specific set of allowed keys, not all strings. TypeScript treats this as a finite union of literal values like:

'one' | 'two' | 'three'

An index signature cannot use that kind of finite union. Index signatures are only for general key categories such as:

• string
• number
• symbol
• template literal pattern types in some cases

If you want to say:

• these exact keys are allowed
• each key maps to the same value shape

then you should use a .

Think of an index signature as a rule for a giant mailbox wall:

• [key: string]: ... means any mailbox label made of text is allowed

Think of a mapped type as a checklist:

• only these three mailboxes must exist: one, two, three

So:

• index signature = open-ended dictionary
• mapped type = exact set of known keys

Your enum is a checklist, not an open-ended dictionary. That is why TypeScript asks you to use a mapped type.

Correct syntax with a mapped type

enum Option {
  ONE = 'one',
  TWO = 'two',
  THREE = 'three'
}

interface OptionRequirement {
  someBool: boolean;
  someString: string;
}

type OptionRequirements = {
  [K in Option]: OptionRequirement;
};

This creates a type equivalent to:

type OptionRequirements = {
  one: OptionRequirement;
  two: OptionRequirement;
  three: OptionRequirement;
};

Example object

const requirements: OptionRequirements = {
  [Option.ONE]: { someBool: true, :  },
  [.]: { : , :  },
  [.]: { : , :  }
};

Consider this code:

enum Option {
  ONE = 'one',
  TWO = 'two'
}

interface OptionRequirement {
  someBool: boolean;
  someString: string;
}

type OptionRequirements = Record<Option, OptionRequirement>;

const config: OptionRequirements = {
  [Option.ONE]: { someBool: true, someString: 'A' },
  [Option.TWO]: { someBool: false, someString: 'B' }
};

Step 1: TypeScript reads the enum

Option.ONE  // 'one'
Option.TWO  // 'two'

The enum values form a small allowed key set.

This pattern is common whenever you have a fixed list of allowed keys.

Feature flags

enum Feature {
  DARK_MODE = 'darkMode',
  BETA_SEARCH = 'betaSearch'
}

type FeatureFlags = Record<Feature, boolean>;

Validation rules by field

type Field = 'email' | 'password';

type ValidationRules = Record<Field, string[]>;

API status handlers

type Status = 'success' | 'error' | 'loading';

type Handlers = Record<Status, () => void>;

Environment-specific config

In real codebases, developers usually use this concept in a few common ways.

1. Record for lookup tables

const labels: Record<Option, string> = {
  [Option.ONE]: 'First option',
  [Option.TWO]: 'Second option',
  [Option.THREE]: 'Third option'
};

This is common for labels, routes, constants, and UI text.

2. Configuration objects with exact coverage

When every enum value must be handled, Record helps prevent missing cases.

const optionConfig: Record<Option, OptionRequirement> = {
  [Option.ONE]: { someBool: true, someString: 'A' },
  [Option.TWO]: { someBool: false, someString:  },
  [.]: { : , :  }
};

1. Using an index signature for a limited set of keys

Broken code:

interface OptionRequirements {
  [key: Option]: OptionRequirement;
}

Why it fails:

• Option is a finite set of keys
• index signatures expect a broad key category like string

Fix:

type OptionRequirements = Record<Option, OptionRequirement>;

2. Using string when you want exact keys

Broken idea:

interface OptionRequirements {
  [key: string]: OptionRequirement;
}

Problem:

• this allows any string key
• you lose protection against invalid keys

Example:

Index signature vs mapped type

// Enum keys
enum Option {
  ONE = 'one',
  TWO = 'two',
  THREE = 'three'
}

interface OptionRequirement {
  someBool: boolean;
  someString: string;
}

Use this for exact enum-based keys

type OptionRequirements = Record<Option, OptionRequirement>;

or

type OptionRequirements = {
  [K in Option]: OptionRequirement;
};

Do not use this

interface OptionRequirements {
  [key: Option]: OptionRequirement;
}

Use Partial if keys are optional

Why can't I use an enum in an index signature?

Because index signatures are for broad key types like string or number, not for a limited union of known values.

What should I use instead of [key: Option]?

Use a mapped type or Record<Option, ValueType>.

Is Record<Option, T> the same as [K in Option]: T?

Yes, for this use case they are effectively the same.

When should I use an index signature?

Use it when keys are not known ahead of time and any string or number key may appear.

How do I make enum-based keys optional?

Use:

Partial<Record<Option, T>>

Will TypeScript force me to include every enum value?

Yes, if you use Record<Option, T> without Partial.

Can I use string unions instead of enums?

Yes. This also works well:

  =  |  | ;
  = <, >;

• Enums — Enums define named constants and are often used as a fixed set of keys.
• Union types — Enum values often behave like a union of allowed literals.
• Mapped types — Mapped types transform a union of keys into an object type.
• Record utility type — Record is a built-in shortcut for common mapped-type patterns.
• Index signatures — Index signatures describe open-ended objects with unknown keys.
• Partial utility type — Partial makes mapped properties optional.
• Object literal type checking — TypeScript checks whether required keys are missing or extra shapes are invalid.
• String literal types — Fixed string values like 'one' | 'two' are closely related to enum-based key sets.