> ## 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 Indexed Access Type
An indexed access type (often referred to as a lookup type) is a TypeScript mechanism used to retrieve the type of a specific property or a set of properties from another type. It allows developers to dynamically reference the type of a property by using bracket notation, operating strictly at the type level rather than the value level.
## Syntax
```typescript theme={"dark"}
type ExtractedType = TargetType[IndexType];
```
* **`TargetType`**: The object, array, or tuple type being queried.
* **`IndexType`**: The type representing the key(s) to look up. This can be a string, numeric, or symbol literal type, a union of literal types, a primitive type (such as `string` or `number` when accessing index signatures or arrays), or a generic type parameter (e.g., `K extends keyof T`).
## Mechanics and Behavior
### 1. Single Property Extraction
When `IndexType` is a single literal type, the resulting type is the exact type of that specific property on the `TargetType`.
```typescript theme={"dark"}
type Configuration = {
endpoint: string;
timeout: number;
secure: boolean;
};
type TimeoutType = Configuration["timeout"];
// Result: number
```
### 2. Union Type Extraction
If `IndexType` is a union of types, TypeScript evaluates the lookup for each member of the union and returns a union of the corresponding property types.
```typescript theme={"dark"}
type EndpointOrSecure = Configuration["endpoint" | "secure"];
// Result: string | boolean
```
### 3. Exhaustive Extraction via `keyof`
Combining an indexed access type with the `keyof` operator extracts a union type representing all possible value types within the `TargetType`.
```typescript theme={"dark"}
type AllConfigurationValues = Configuration[keyof Configuration];
// Result: string | number | boolean
```
### 4. Array and Tuple Extraction
Indexed access types can be applied to arrays and tuples using numeric literal types or the primitive `number` type.
* **Tuples**: Indexing with a specific numeric literal extracts the type at that exact position.
* **Arrays/Tuples**: Indexing with the primitive `number` type extracts a union of all possible element types within the array or tuple.
```typescript theme={"dark"}
type DataTuple = [string, number, boolean];
type FirstElement = DataTuple[0];
// Result: string
type AnyTupleElement = DataTuple[number];
// Result: string | number | boolean
type StringArray = string[];
type ArrayElement = StringArray[number];
// Result: string
```
## Strict Type Constraints
The `IndexType` passed into the brackets must be a valid type that exists as a key or index signature on the `TargetType`.
1. **Invalid indices yield errors**: Attempting to use a type that cannot index the target type will result in a compiler error (`Type 'X' cannot be used to index type 'Y'`).
2. **Values cannot be used as indices**: You cannot pass a runtime variable into an indexed access type unless you extract its type using the `typeof` operator.
```typescript theme={"dark"}
const key = "timeout";
// ERROR: 'key' refers to a value, but is being used as a type here.
type InvalidLookup = Configuration[key];
// VALID: Extracts the literal type "timeout" from the constant value.
type ValidLookup = Configuration[typeof key];
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
