TypeScript Indexed Access Types: T[K], T[number] and More

An indexed access type looks up the type of a property on another type, with the same bracket syntax JavaScript uses for property access. Person["age"] is number, and Person["address"]["city"] is string.

type Person = {
  name: string;
  age: number;
  address: { city: string; zip: string };
};

type Age = Person["age"];                 // number
type City = Person["address"]["city"];    // string
type Address = Person["address"];         // { city: string; zip: string }

const age: Age = 36;
const home: Address = { city: "London", zip: "N1" };
const city: City = home.city;

console.log(age, city); // 36 London

The benefit is a single source of truth. Age is not a second copy of number: if Person["age"] changes to string, every type written as Person["age"] changes with it. Indexed access types are compile-time only; they emit no JavaScript.

Union Keys and T[keyof T]

The index can be a union of keys. The result is the union of the property types:

type Product = {
  id: number;
  title: string;
  inStock: boolean;
};

type IdOrTitle = Product["id" | "title"];  // number | string
type AnyValue = Product[keyof Product];    // number | string | boolean

function describe(value: AnyValue): string {
  return `${typeof value}: ${value}`;
}

const p: Product = { id: 7, title: "Lamp", inStock: false };
for (const key of ["id", "title", "inStock"] as const) {
  console.log(describe(p[key]));
}
// number: 7
// string: Lamp
// boolean: false

Product[keyof Product] is the type-level way to say "any property value of Product". Asking for a key that does not exist is a compile error: Product["price"] gives error TS2339: Property 'price' does not exist on type 'Product'.

Optional Properties Include undefined

With strictNullChecks (on under strict), the type of an optional property includes undefined, and so does its indexed access type:

type Profile = { name: string; nickname?: string };

type Nick = Profile["nickname"]; // string | undefined

To drop the undefined, wrap it: NonNullable<Profile["nickname"]> is string.

Array Element Types with T[number]

Arrays are indexed by numbers, so indexing an array type with number gives the element type. It also works through several levels:

type Order = {
  id: number;
  items: { sku: string; qty: number }[];
};

type Orders = Order[];

type OneOrder = Orders[number];             // Order
type Item = Order["items"][number];         // { sku: string; qty: number }
type Sku = Orders[number]["items"][number]["sku"]; // string

const item: Item = { sku: "A-100", qty: 2 };
const sku: Sku = item.sku;
console.log(sku, item.qty); // A-100 2

This is useful when a type comes from somewhere you do not control, such as a generated API client: ApiResponse["data"]["users"][number] names the user type without anyone having exported it.

Tuples: Index by Position

A tuple type can be indexed with a specific position, with number for the union of all element types, and with "length" for its length as a literal type:

type Entry = [string, number, boolean];

type First = Entry[0];         // string
type Second = Entry[1];        // number
type AnyElement = Entry[number]; // string | number | boolean
type Len = Entry["length"];    // 3

const len: Len = 3;
const entry: Entry = ["ada", 36, true];
const first: First = entry[0];

console.log(first, len); // ada 3
// Entry[3] is error TS2493: Tuple type 'Entry' of length '3' has no element at index '3'.

(typeof arr)[number]: A Union from a const Array

The most common real-world use: keep a list of allowed values as an array (so you can loop over it at runtime) and derive the union type from it (so the compiler checks it).

const ROLES = ["admin", "editor", "viewer"] as const;

type Role = (typeof ROLES)[number]; // "admin" | "editor" | "viewer"

function canPublish(role: Role): boolean {
  return role !== "viewer";
}

for (const role of ROLES) {
  console.log(role, canPublish(role));
}
// admin true
// editor true
// viewer false

Two parts make it work. as const makes the array a readonly tuple of literal types; without it, ROLES is string[] and (typeof ROLES)[number] is just string. Then typeof turns the value into a type, and [number] collects its elements into a union. The parentheses are optional (typeof ROLES[number] means the same), but they make the order of operations clear.

Checking a String Against the Array

That readonly tuple has one surprise. Its includes method only accepts the element type, so you cannot pass an arbitrary string to it:

// This does not compile: includes() on the tuple only accepts a Role
const ROLES = ["admin", "editor", "viewer"] as const;
type Role = (typeof ROLES)[number];

function isRole(value: string): boolean {
  return ROLES.includes(value);
}

console.log(isRole("admin"));

index.ts(6,25): error TS2345: Argument of type 'string' is not assignable to parameter of type '"admin" | "editor" | "viewer"'.

Widen the array to readonly string[] for the check, and turn the function into a type guard so a successful check narrows the value:

const ROLES = ["admin", "editor", "viewer"] as const;
type Role = (typeof ROLES)[number];

function isRole(value: string): value is Role {
  return (ROLES as readonly string[]).includes(value);
}

const input: string = "editor"; // imagine this came from a URL or a form
if (isRole(input)) {
  const role: Role = input; // narrowed to Role here
  console.log("valid role:", role);
}
console.log(isRole("owner")); // false

This pattern gives you one list for both jobs: the runtime check uses the array, and the type is derived from it, so they cannot drift apart.

Indexed Access in Generics: T[K]

Inside a generic, T[K] with K extends keyof T is the type of whichever property the caller picked:

function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map((item) => item[key]);
}

const users = [
  { name: "Ada", age: 36 },
  { name: "Linus", age: 28 },
];

const names = pluck(users, "name"); // string[]
const ages = pluck(users, "age");   // number[]

The K extends keyof T constraint is what makes T[K] legal. Without it, TypeScript cannot know that K is a key of T and reports error TS2536: Type 'K' cannot be used to index type 'T'.

Syntax at a Glance

The index is always a type. Person[key] where key is a const variable fails with two errors: error TS2538: Type 'key' cannot be used as an index type. and error TS2749: 'key' refers to a value, but is being used as a type here. Did you mean 'typeof key'?.