How to fix Conditional type cannot reference type variable in constraint in TypeScript

The constraint portion of a conditional type (after extends) is evaluated first and cannot reference inferred types. Only the true and false branches can use inferred variables.

Wrong - constraint tries to reference inferred type:

type Wrong<T> = T extends (infer U extends string)[] ? U : never;
// Error: Cannot reference inferred type in constraint

Correct - reference inferred type in branch:

type Correct<T> = T extends (infer U)[] ? (U extends string ? U : never) : never;

The key difference: the constraint checks if T is an array, then the branch checks if U (the inferred element type) is a string.

If you need to constrain a type variable, apply the constraint to the generic type parameter itself, not in the conditional clause.

Problem:

type ExtractString<T> = T extends (infer Item extends string)[] ? Item : never;
// Error: Cannot reference inferred type in constraint

Solution - constrain the outer parameter:

type ExtractString<T extends string[]> = T extends (infer Item)[] ? Item : never;

Or use the constraint in TypeScript 5+ style:

type ExtractString<T> = T extends (infer Item)[]
  ? (Item extends string ? Item : never)
  : never;

When you need to both infer and constrain a type, use nested conditionals where the inner conditional checks the constraint.

Problem:

type GetProperty<T, K> = T extends Record<K extends string ? K : never, infer V> ? V : never;
// Error: Cannot use constraint with inferred type

Solution - nested conditionals:

type GetProperty<T, K> = K extends string
  ? K extends keyof T
    ? T[K]
    : never
  : never;

This first checks if K is a string, then checks if it's a key of T, avoiding the constraint reference problem.

Refactor your conditional type to infer the variable first at the top level, then apply constraints in the branches.

Problem:

type Unwrap<T> = T extends Promise<infer U extends { id: string }> ? U : T;
// Error: Cannot reference inferred type in constraint

Solution - separate inference from constraint:

type Unwrap<T> = T extends Promise<infer U>
  ? (U extends { id: string } ? U : never)
  : T;

The key is: infer U without constraints, then check the constraint in the branch.

TypeScript 5.4 introduced support for constraints on inferred types, but with specific syntax. Ensure you're using the correct syntax for your version.

TypeScript 5.4+ correct syntax:

// This syntax IS allowed in 5.4+ when properly structured
type GetString<T> = T extends (...args: any[]) => (infer R extends string)
  ? R
  : never;

However, this only works in specific contexts (like function return types). For array element inference, use the nested approach:

type GetStringElement<T> = T extends (infer E)[]
  ? E extends string ? E : never
  : never;

Check your tsconfig.json for the compilerOptions.target or compilerOptions.lib to ensure you're on TypeScript 5.4+.

If your conditional type is complex, create intermediate helper types to handle inference and constraints separately.

Problem:

type Complex<T> = T extends {
  data: (infer Items extends { id: string })[]
} ? Items : never;
// Error: Cannot reference inferred type in constraint

Solution - split into helper types:

// First helper: extract the array
type ExtractDataArray<T> = T extends { data: infer D } ? D : never;

// Second helper: extract array elements
type ArrayElements<T> = T extends (infer E)[] ? E : never;

// Third helper: check if has id
type HasId<T> = T extends { id: string } ? T : never;

// Compose them
type Complex<T> = HasId<ArrayElements<ExtractDataArray<T>>>;

This approach is clearer and avoids the constraint reference error.