Get Function Argument Types with Parameters in TypeScript

TypeScript represents a function's parameter list as a tuple type. Use the built-in Parameters<T> utility to extract that tuple from a function type. You will also learn why typeof is needed for function declarations, why keyof is not used for parameters, and how conditional types can implement the same idea.

A function has a function type describing its inputs and output. For example, this function:

function test(a: string, b: number): void {
  console.log(a, b);
}

has a type similar to:

(a: string, b: number) => void

Its input types can be represented as the tuple:

type TestArguments = [a: string, b: number];

TypeScript provides the built-in Parameters<T> utility type to extract this tuple:

type TestArguments = Parameters<typeof test>;
// [a: string, b: number]

This matters when you want one type definition to stay synchronized with a function. If the function's parameters change later, every place that uses receives the updated tuple automatically.

Think of a function as a machine with an input tray and an output slot.

• typeof test is the machine's instruction sheet: it says the machine accepts a string and a number.
• Parameters<typeof test> reads the input tray requirements and returns [string, number].
• ReturnType<typeof test> reads the output slot requirement and returns the output type.
• keyof typeof test asks for named properties on the machine object, such as .name or custom attached properties. It does not ask what belongs in the input tray.

Use Parameters<T> with a function type.

function test(a: string, b: number): void {
  console.log(a, b);
}

type TestParameters = Parameters<typeof test>;
// type TestParameters = [a: string, b: number]

const validArguments: TestParameters = ["Ada", 42];

test(...validArguments);

TestParameters is a tuple, not merely (string | number)[]. Tuple positions are preserved:

• the first item must be a string
• the second item must be a number

const invalidArguments: TestParameters = [42, "Ada"];
// Error: number is not assignable to string

Consider a reusable logging wrapper:

function formatPrice(amount: number, currency: string): string {
  return `${currency} ${amount.toFixed(2)}`;
}

type PriceArguments = Parameters<typeof formatPrice>;

const args: PriceArguments = [19.5, "USD"];
const result = formatPrice(...args);

Step by step:

1. typeof formatPrice produces the function type:

   (amount: number, currency: string) => string
   

2. Parameters<typeof formatPrice> inspects the function's parameter list.

3. It creates this tuple type:

Parameters<T> is useful whenever another API should accept exactly the same arguments as an existing function.

• Logging or timing wrappers: Forward a function's arguments without manually repeating their types.
• Event handlers: Reuse the argument list of a callback or listener.
• Test helpers: Create typed helpers that invoke production functions with valid inputs.
• Dependency injection: Store constructor or factory arguments in a correctly typed tuple.
• API clients: Reuse argument types for retry, caching, or telemetry layers.

Example: a generic function caller:

function callLater<F extends (...args: any[]) => any>(
  fn: F,
  args: Parameters<F>
): void {
  setTimeout(() => fn(...args), 1000);
}

function greet(name: string, excited: boolean): void {
  console.log(excited ? `Hello, ${name}!` : `Hello, ${name}.`);
}

callLater(greet, [, ]);

In real projects, Parameters<T> is commonly paired with generics and argument forwarding.

Typed wrapper functions

A wrapper can preserve the argument list and return type of any callback:

function withLogging<F extends (...args: any[]) => any>(fn: F) {
  return (...args: Parameters<F>): ReturnType<F> => {
    console.log("Calling with:", args);
    return fn(...args);
  };
}

function add(left: number, right: number): number {
  return left + right;
}

const loggedAdd = withLogging(add);
const total = loggedAdd(2, 3);

loggedAdd is inferred as (left: number, right: number) => number.

Typed constructor arguments

Forgetting typeof for a function declaration

test is a value name, not a type name.

function test(a: string, b: number): void {}

type Args = Parameters<test>;
// Error: 'test' refers to a value, but is being used as a type here.

Use:

type Args = Parameters<typeof test>;

Using ReturnType<test> instead of ReturnType<typeof test>

The same value-versus-type rule applies:

type Result = ReturnType<typeof test>;

Using keyof to get arguments

keyof gets property names from object types. Function parameters are not object properties.

// Function declaration: use typeof
type Args = Parameters<typeof myFunction>;
type Result = ReturnType<typeof myFunction>;

// Function type alias: no typeof needed
type Handler = (id: string, retry?: boolean) => Promise<void>;
type HandlerArgs = Parameters<Handler>;
// [id: string, retry?: boolean | undefined]

// Individual tuple elements
type First = Parameters<typeof myFunction>[0];

// Forward arguments in a generic wrapper
function wrap<F extends (...args: any[]) => any>(fn: F) {
  return (...args: Parameters<F>): ReturnType<F> => fn(...args);
}

Rules:

How do I get argument types from a function in TypeScript?

Use Parameters<typeof functionName>. For example, Parameters<typeof test> produces [a: string, b: number].

Why do I need typeof in Parameters<typeof test>?

test is a JavaScript value. typeof test converts that value reference into its TypeScript type so a type utility can use it.

Does Parameters<T> include optional parameters?

Yes. For (id: string, verbose?: boolean) => void, it produces [id: string, verbose?: boolean | undefined].

Does Parameters<T> work with rest parameters?

Yes. For (...values: number[]) => number, it produces number[] as the parameter tuple/rest representation.

Why does keyof typeof test return never?

keyof asks for named properties, not function inputs. A normal function declaration has no declared custom properties, so there are no keys to produce.

• typeof in type positions — obtains the type of a function, object, or other runtime value.
• ReturnType<T> — extracts what a function returns.
• Conditional types — power utilities that choose or extract types with extends.
• infer keyword — captures a type part, such as a function's parameter tuple, inside a conditional type.
• Tuple types — represent ordered, fixed or partly fixed lists of values.
• Rest parameters and spread syntax — allow tuples to be received and forwarded as function arguments.
• ConstructorParameters<T> — extracts arguments accepted by a class constructor.
• Generic functions — let wrappers preserve types for many different functions.