Built-ins: ReturnType, Parameters, InstanceType, etc.

function greet(name: string) { return `Hi ${name}` }

// built-ins
type R = ReturnType<typeof greet>        // string
type P = Parameters<typeof greet>        // [name: string]

class Box { constructor(public w: number, public h: number) {} }

type I = InstanceType<typeof Box>            // Box
type C = ConstructorParameters<typeof Box>    // [w: number, h: number]

function move(this: { x: number; y: number }, dx: number, dy: number) {
  this.x += dx; this.y += dy
}

type ThisT = ThisParameterType<typeof move>        // { x: number; y: number }

type MoveNoThis = OmitThisParameter<typeof move>   // (dx: number, dy: number) => void

class Http {
  constructor(public base: string) {}
  get(path: string) { return Promise.resolve(`${this.base}${path}`) }
}

type Client = InstanceType<typeof Http>                 // Http
type GetReturn = ReturnType<Client["get"]>             // Promise<string>

type GetArgs = Parameters<Client["get"]>               // [path: string]

type GetResolved = GetReturn extends Promise<infer U> ? U : GetReturn  // string

// Tips
// - Prefer built-ins over custom re-implementations
// - Document when a type exposes this
// - Avoid any in public APIs; utilities lose precision
// - Keep function types nominal via object wrappers if needed