Get the TypeScript type of a variable

Is there an expression that evaluates to the type that TypeScript believes a values inhabits?

I've been trying to search, but all the answers are about Javascript's runtime types and not TypeScript's types.

For example

const a = 5 as unknown as string;
console.log(typeof a);
// number

The above print "number" because it's getting a type from JavaScript at runtime. Typescript, however, assumes that a is a String. The following type checks because TypeScript believes a is a String:

function naiveType(v: string): string {
  return "string";
}

const a = 5 as unknown as string;
console.log(naiveType(a));

For better or worse this is not possible with the TypeScript compiler.

One of TypeScript's Design Non-Goals is that TypeScript would:

> 5. Add or rely on run-time type information in programs, or emit different code based on the results of the type system. Instead, encourage programming patterns that do not require run-time metadata.

If there were a tsTypeof operator that acted the way you want, the TypeScript code

// TS
const a = 5 as unknown as string;
console.log(tsTypeof a);

would need to compile to something like the following JavaScript

// JS
const a = 5;
console.log("string");

while the TypeScript code

// TS
const a = 5 as unknown as number;
console.log(tsTypeof a);

would need to compile to something like

// JS
const a = 5;
console.log("number");

which means that tsTypeof a would compile to different things depending on the results of the type system, which violates the rule.

If someone were to open a feature request for such an operator, it would almost certainly be declined, since one couldn't truthfully check the box in the TypseScript feature request issue template that says

> ☑ This could be implemented without emitting different JS based on the types of the expressions.

If you want something like this, you'd need to add a build step that used, say, the TypeScript compiler API to process your TypeScript code and convert it to a form that preserves the compile-time type information. There are certainly existing frameworks that do this for you, such as Deepkit's typeOf() function. But this takes us outside the realm of pure TypeScript and into external tools, which isn't the focus of this question.