In TypeScript, you need a second value — a test double or a wrapper — to have exactly the same type as an existing function called `parseConfig`. How do you express that without retyping its signature by hand?

## Two namespaces, one keyword TypeScript keeps *values* and *types* in separate namespaces. `const parseConfig = ...` declares a value; `type Parse = ...` declares a type. The bridge between them, in the value-to-type direction, is the type query: ```ts function parseConfig(input: string, strict = false): Record<string, string> { return strict ? JSON.parse(input) : {}; } type Parse = typeof parseConfig; // (input: string, strict?: boolean) => Record<string, string> ``` The keyword is the same one JavaScript uses, but the position decides the meaning. In an expression, `typeof x` is a runtime operator producing a string. After a `:`, inside a type alias, in a generic argument — anywhere a type is expected — `typeof x` is a compile-time query that produces no code at all. ## Why you would use it The direct benefit is that a hand-written duplicate of a signature drifts. Consider a test double: ```ts const fake: typeof parseConfig = (input, strict) => ({ received: input, strict: String(strict), }); ``` Because `fake` is annotated with the query, its parameters are contextually typed — no annotations needed on the arrow — and the day someone adds a third parameter to `parseConfig` or changes its return type, `fake` fails to compile. If instead you had written `const fake: (input: string, strict?: boolean) => Record<string, string> = ...`, the copy would keep compiling against a signature that no longer exists anywhere. The same applies to wrappers, decorated versions, adapter tables, and anywhere you need "the same thing as that". ## What the query captures Everything the compiler inferred for the value, not just the callable part. If the function carries properties — the hybrid shape of a callable plus its data — the query brings them along: ```ts function tick(label: string): number { tick.count += 1; return tick.count; } tick.count = 0; type Tick = typeof tick; // callable AND { count: number } const spy: Tick = Object.assign((label: string) => 0, { count: 0 }); ``` That is a real advantage over writing the signature by hand, where the property is easy to forget. ## What the query accepts A type query takes an *entity name*: an identifier, or a dotted path of identifiers. ```ts type A = typeof parseConfig; // ok type B = typeof config.parse; // ok - dotted path type C = typeof import('./config'); // ok - the module's shape // type D = typeof parseConfig('x'); // error: not an entity name ``` The last line is the mistake people make when they actually want the *return* type. A call is an expression, and the query does not evaluate expressions — nothing is executed at compile time. The return type is obtained with a separate mechanism, not by pretending to call the function. A second restriction follows from the two-namespace rule: the operand must exist as a **value**. `typeof SomeTypeAlias` is an error, because a type alias declares nothing in value space. Conversely, some declarations exist in both namespaces — a class declares a type (its instances) and a value (the class object) — which is why `typeof` applied to a class means something quite different from the bare class name. ## Erasure, again A type query emits nothing. `type Parse = typeof parseConfig` compiles to no JavaScript, and using `Parse` as an annotation adds no check. The value `parseConfig` still has to exist at runtime for the *value* references to work, but the query itself is purely a compile-time lookup. This is why a type-only import of a value is enough to query it: the query never needs the value to be present in the emitted module. ## Interview framing Say it in one line — "`typeof` in type position reads back the type the compiler already inferred for a value" — then give the reason: it keeps mocks, wrappers and re-exports in lockstep with the original instead of duplicating a signature that will drift. Then show you know the edges: identifiers and dotted paths only, values only, and it produces no runtime code.