Leverage TypeScript to Extract Every Overload from Functions

TypeScript developers often face a frustrating limitation when working with overloaded functions: the language only infers the last call signature, leaving the rest inaccessible for type transformations. One engineer stumbled upon an ingenious workaround that flips this behavior on its head.

The breakthrough came while trying to enhance the developer experience for translation libraries like i18next. Instead of passing string keys directly, the engineer wanted to use lambda selectors that preserve type safety and navigation capabilities. This led to a deeper dive into TypeScript’s type system, specifically how it handles function overloads.

The Overload Inference Problem

Consider a function with multiple call signatures:

type MultiOverload = {
  (): void;
  (id: number): string;
  (name: string, age: number): boolean;
};

When attempting to extract these signatures using TypeScript’s type inference:

type Extracted = (Parameters<MultiOverload> extends infer T
  ? T extends any
    ? (...args: T) => ReturnType<MultiOverload>
    : never
  : never);

The result only captures the last signature:

type Extracted = (name: string, age: number) => boolean;

This happens because TypeScript’s type inference for overloaded functions prioritizes the last declaration by design. The language specification explicitly states that when inferring from an overloaded type, only the final signature is considered.

Intersection Types as a Workaround

The solution emerged from experimenting with intersection types. While MultiOverload & SomeSignature and SomeSignature & MultiOverload appear logically equivalent at runtime, their behavior in TypeScript’s type system differs significantly.

When you structure the intersection as:

type Reordered = (name: string, age: number => boolean) & MultiOverload;

The type system reprioritizes the overload order, making the first signature visible to inference:

type Extracted = (id: number) => string;

This unexpected behavior opened the door to a recursive approach for extracting all overloads.

Building the Extraction Utility

The final implementation uses a recursive type that systematically exposes each overload:

type ExtractCallSignatures<T, Accumulator = {}> = (
  T extends (...args: infer Params) => infer Return
    ? (
        ((...args: Params) => Return) |
        ExtractCallSignatures<Accumulator & T, ((...args: Params) => Return) & Accumulator>
      )
    : never
);

This utility works by:

• Taking the target overloaded function type T
• Inferring its last visible signature
• Adding that signature to an intersection accumulator
• Recursively repeating the process until all signatures are collected

The implementation handles edge cases like:

• Empty overload sets
• Single-signature functions
• Deeply nested intersection types

Practical Applications

This technique unlocks several powerful use cases:

• API Transformation: Safely modify function signatures while preserving overload structure
• Type-Safe Wrappers: Create decorator functions that maintain original call semantics
• Schema Validation: Extract complete function signatures for runtime type checking
• Tooling Integration: Enable IDE features like signature navigation for complex APIs

For translation libraries specifically, this means developers can now write:

translate($ => $.user.profile.title);

Instead of the less type-safe:

translate("user.profile.title");

Looking Ahead

TypeScript’s type system continues to evolve, with the team considering improvements to overload handling. This discovery demonstrates how creative approaches can unlock capabilities within the language’s existing constraints. As more developers experiment with these patterns, we may see standardized solutions emerge for common type manipulation challenges.

The technique remains experimental and requires careful implementation to avoid circular type references. However, for teams heavily invested in TypeScript’s type system, it represents a significant step toward more expressive type-level programming.