This is not a TypeScript standard library, it's ECMAScript, so you won't find a TS-specific reference.

Luckily there are lots of references for that around. I normally tend to just do a quick Google search and end up in places like MDN, which IMO the best place for modern JS reference. If you like Microsoft and MSDN stuff, they have their own JS-specific reference, but I don't think it's as good as MDN.

The problem with the above is that it doesn't really refer to how types are treated by TS. You'll find a reference to Map(), not to Map<T1, T2>(). So which type to use where, especially where generics come into play, is a bit implied.

I found that to quickly check how those types are treated, inspecting a type (e.g. hitting F12 when your cursor is over a type in Visual Studio Code) suffices. It'll take you to the specific (internal) definition of the type. For example, for Map, you'll be taken to this piece of code. All the definition libs are also available online if you need to check them beforehand.

Current

The TypeScript team, and other TypeScript involved teams, created a TSDoc specification. https://tsdoc.org/

Example straight from the docs:

export class Statistics {
  /**
   * Returns the average of two numbers.
   *
   * @remarks
   * This method is part of the {@link core-library#Statistics | Statistics subsystem}.
   *
   * @param x - The first input number
   * @param y - The second input number
   * @returns The arithmetic mean of `x` and `y`
   *
   * @beta
   */
  public static getAverage(x: number, y: number): number {
    return (x + y) / 2.0;
  }
}

Past

TypeScript uses JSDoc. e.g.

/** This is a description of the foo function. */
function foo() {
}

To learn jsdoc : https://jsdoc.app/

But you don't need to use the type annotation extensions in JSDoc.

You can (and should) still use other jsdoc block tags like @returns etc.

Just an example. Focus on the types (not the content).

JSDoc version (notice types in docs):

/**
 * Returns the sum of a and b
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function sum(a, b) {
    return a + b;
}

TypeScript version (notice the re-location of types):

/**
 * Takes two numbers and returns their sum
 * @param a first input to sum
 * @param b second input to sum
 * @returns sum of a and b
 */
function sum(a: number, b: number): number {
    return a + b;
}