Extract Interface Property Types in TypeScript with Indexed Access Types

TypeScript can extract a property type directly from an interface with an indexed access type. Write I2["y"] to reuse the type of I2's y property without creating a duplicate interface or a placeholder variable. This keeps your code synchronized when the library updates its type definitions.

An interface is a type, not a runtime JavaScript value. That is why this does not work:

// Invalid: I2 is a type, not an object available at runtime.
type Y = typeof I2.y;

The typeof operator in a type position gets the type of a value that exists (or is declared) as a value. For example, if value is a variable, typeof value produces its type.

To look up a member of a type directly, TypeScript provides indexed access types. They use square brackets:

type Y = I2["y"];

I2["y"] means: “get the type associated with the y key in I2.” It is the type-level equivalent of reading object["y"] at runtime.

This matters because library declarations often contain nested object shapes, callback signatures, configuration objects, and API response types. Reusing a property type avoids copying it into your project, so changes made by the library are automatically reflected in your code when you update its typings.

Think of an interface as a blueprint with labeled rooms.

• I2 is the complete blueprint.
• y is one room inside that blueprint.
• I2["y"] asks TypeScript to give you the blueprint for that one room.

You do not need to build a fake house (declare const value: I2) just to inspect a room. Indexed access lets you refer to the room directly from the blueprint.

Use this syntax to extract a property type:

type PropertyType = InterfaceName["propertyName"];

For the interfaces in the question:

interface I1 {
  x: any;
}

interface I2 {
  y: {
    a: I1;
    b: I1;
    c: I1;
  };
  z: any;
}

type I2Y = I2["y"];

const value: I2Y = {
  a: { x: "first" },
  b: { x: 2 },
  c: { x: true }
};

I2Y is equivalent to the object type declared for I2.y:

{
  : ;
  : ;
  : ;
}

Consider this code:

interface User {
  id: string;
  profile: {
    displayName: string;
    email: string;
  };
}

type Profile = User["profile"];

const profile: Profile = {
  displayName: "Ada",
  email: "ada@example.com"
};

Step by step:

1. User defines an object type with id and profile properties.

2. User["profile"] performs a type lookup using the key "profile".

3. TypeScript finds the declared type of profile inside User.

4. Profile becomes:

Indexed access types are useful whenever one type is the source of truth and you need one part of it elsewhere.

• Library configuration: Reuse one section of a third-party library's options type.

  type DatabaseOptions = AppOptions["database"];
  

• API data: Extract the type of a nested API response field.

  type UserRecord = ApiResponse["user"];
  

• Event handlers: Reuse a callback type from an interface.

  type OnSave = EditorOptions["onSave"];
  

• Component props: Share the type of a nested prop between UI components.

  type ButtonStyle = Theme["button"];
  

• State models: Extract one slice of application state.

    = [];
  

In production code, give extracted types meaningful aliases rather than repeatedly writing long lookups:

type RequestHeaders = HttpRequest["headers"];
type RequestBody = HttpRequest["body"];

This makes function signatures easier to read:

function validateHeaders(headers: RequestHeaders): boolean {
  return headers.authorization !== undefined;
}

Indexed access is also commonly combined with generics. A reusable helper can return the value type for any valid object key:

type ValueOf<T, K extends keyof T> = T[K];

interface Settings {
  retryCount: number;
  endpoint: string;
}

type Endpoint = ValueOf<Settings, "endpoint">;
// string

Using typeof with an interface name

This is invalid:

interface I2 {
  y: string;
}

type Y = typeof I2.y;

I2 is erased when TypeScript becomes JavaScript. It is not a runtime object, so typeof has no value to inspect. Use I2["y"] instead.

Using dot notation in a type lookup

This is not TypeScript's indexed-access syntax:

// Invalid
type Y = I2.y;

Use square brackets and a key:

type Y = I2["y"];

Misspelling a property key

TypeScript rejects keys that do not exist:

// Error: Property 'missing' does not exist on type 'I2'.
type  = [];

// Extract one property type
type Y = I2["y"];

// Extract a nested property type
type A = I2["y"]["a"];

// Extract types for multiple keys
type Values = I2["y" | "z"];

// Get every key
type Keys = keyof I2;

// Get a union of every property value type
type AllValues = I2[keyof I2];

// Generic property lookup
type ValueOf<T, K extends keyof T> = T[K];

// Get an array element type
type Item = Response["items"][number];

Rules to remember:

• Use Type["key"], not Type.key.
• The key must exist on the type.
• typeof is for values; indexed access is for properties of types.

How do I get the type of an interface property in TypeScript?

Use an indexed access type:

type PropertyType = MyInterface["propertyName"];

For the question's example, use type I2Y = I2["y"];.

Why does typeof I2.y not work?

I2 is an interface, which exists only in TypeScript's type system. It is not a runtime JavaScript object. typeof in a type annotation needs a value to inspect.

Can I extract a nested property type?

Yes. Chain indexed accesses:

type AType = I2["y"]["a"];

Do I need to declare a variable first?

No. declare const value: I2; type Y = typeof value.y; works, but type Y = I2["y"]; is direct and clearer.

Can I use a property name stored in a type alias?

Yes, as long as it is a valid key:

  = ;
 Y = [];

• keyof operator — Produces the valid keys of a type and is commonly used with T[K].
• typeof type operator — Extracts a type from a value, function, class, or constant.
• Generic constraints — K extends keyof T ensures a generic key is valid for an object type.
• Mapped types — Transform every property in an existing type while preserving its keys.
• Conditional types — Build types that change based on whether another type meets a condition.
• Array element types — Use T[number] to get the type of an array's items.
• Structural typing — Explains why compatible object shapes are assignable even if they have extra properties.