TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}'

TypeScript is a programming language that builds on JavaScript, providing static type definitions. In simpler terms, TypeScript allows developers to define the structure and types of their data, ensuring that the code behaves as expected during runtime. It acts as a powerful tool for catching errors before code is executed, making it a popular choice for large-scale applications and teams. Types (or type annotations) are at the heart of TypeScript and represent the kinds of values a variable, function, or object can hold. Examples of such types include string, number, boolean, and user-defined types like interfaces, enums, and more.

If you're excited about learning TypeScript or want to explore AI tools for learning code, make sure to check my blog and consider using GPTeach to level up your skills!

Below, we'll explore what types are and dive deeper into understanding the common TypeScript error: "TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}'." Misunderstandings surrounding type definitions often lead to this error, and we’ll cover ways to fix it.

What Are Types?

In TypeScript, types are a way to describe the shape of data and what kind of values it can hold. By explicitly defining types, developers can catch type-related bugs at compile time, which significantly reduces runtime errors. Here are a few simple examples of types:

// Basic types
let name: string = "John"; // string type
let age: number = 30; // number type
let isWorking: boolean = true; // boolean type

// Array type
let numbers: number[] = [1, 2, 3]; // array of numbers

// Custom type using `type` keyword
type Point = { x: number; y: number };
let point: Point = { x: 10, y: 20 };

// Function return type
function double(value: number): number {
  return value * 2;
}

Types can also be extended and combined using more advanced structures, such as interfaces, type intersections, or type unions. This gives developers maximum flexibility and more robust static typing.

Understanding TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}'

The error TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}' occurs when TypeScript detects a mismatch in return types for functions with identical call signatures (functions that take the same parameters, but return different types). Since functions need to provide a consistent behavior for all usage scenarios, having conflicting return types is not allowed.

Let’s break that down with some simple examples.

Example of the Error

Here’s code that causes the TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}' error:

type ExampleFunc = (() => string) | (() => number);

let myFunction: ExampleFunc;

// Error: TS2204: Call signatures with no arguments have incompatible return types 'string' and 'number'.
myFunction = () => {
  return Math.random() > 0.5 ? "a string" : 42;
};

Why does this happen? In the above code, we’re defining ExampleFunc as a union type of two call signatures: one that returns a string and another that returns a number. TypeScript raises the TS2204 error because, during execution, it won’t know how to reliably narrow or predict which return type is valid.

How to Fix TS2204

To fix TS2204, you need to ensure that functions sharing the same call signature have compatible or consistent return types. Here are a few approaches to resolve this issue.

1. Narrow the Union (Redefine Return Types)

If you’re mixing return types, you may need to adjust your types to match a compatible structure. One solution is using a union type as the return type.

type ExampleFunc = () => string | number;

let myFunction: ExampleFunc;

// This now works because the return type 'string | number' is compatible with the call signature.
myFunction = () => {
  return Math.random() > 0.5 ? "a string" : 42;
};

By specifying the return type as string | number, you make it clear that the function can return either value at runtime. This resolves the TS2204 error.

2. Use Overloads

TypeScript supports function overloading, which allows you to define multiple call signatures for a single function. Here’s how you can apply it:

function myFunction(): string;
function myFunction(): number;
function myFunction(): any {
  return Math.random() > 0.5 ? "a string" : 42;
}

// Works because the call signatures are clear and explicit.
const result1: string = myFunction();
const result2: number = myFunction();

Overloading informs TypeScript of all possible return types and provides more clarity at the calling site. This avoids ambiguities seen in TS2204.

3. Avoid Mixing Call Signatures in Unions

A more restrictive fix is to avoid creating unions of functions with conflicting return types altogether. Instead, use an object-based design to handle different possible behaviors more explicitly.

type ExampleFunc = {
  kind: "string";
  call: () => string;
} | {
  kind: "number";
  call: () => number;
};

let myFunction: ExampleFunc = {
  kind: "string",
  call: () => "a string"
};

// You manually control behavior via the `kind` field.
if (myFunction.kind === "string") {
  const val = myFunction.call(); // Function safely returns a string.
}

By tagging each variant with a kind field, you can be more explicit about behavior and avoid runtime confusion.

Important to Know!

Functions in TypeScript must maintain consistent return types within a shared call signature. If return types conflict, TypeScript raises errors like TS2204.
Union types in function signatures require careful design. Ensure compatibility by narrowing possible return types or leveraging overloaded function definitions.
Always aim for clarity in defining types. This helps both TypeScript’s compiler and your colleagues to understand the code better.

Frequently Asked Questions (FAQs)

What triggers TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}'?

The error occurs when there are conflicting return types in union type call signatures that cannot be resolved. For example, TypeScript doesn’t know how to handle () => string vs () => number when combined in a union.

Can I mix strings and numbers in return values?

Yes, but you must explicitly define a compatible return type, such as string | number.

Why does TypeScript enforce consistent return types?

TypeScript prioritizes static type safety to prevent unexpected runtime bugs. By ensuring return type consistency, the compiler eliminates potential conflicts.

By understanding TypeScript’s type system and following best practices, you can avoid errors like TS2204: Call signatures with no arguments have incompatible return types '{0}' and '{1}' and write cleaner, more reliable code.

Ahmad Tibibi @ahmad_tibibi