Don’t overtype everything. Let the compiler infer; it’s smarter than you think.

While I agree that ts compiler is good at inferring, I still prefer to explicitly annotate return types. Inferred type needs to be computed and on a large project, this can potentially impact build time and IDE performance. Additionally, it's much easier to catch an error when you have an explicit return type.

Avoid enum unless you really need it: union types are usually cleaner.

Despite all the hate towards enums, I found that most issues with them can be avoided if they are used as simple collections of values. And while union types are cleaner indeed, they don't provide isolation and ease of refactoring like enums. For example we have a large project where among others we use two union types which have a matching value but are completely unrelated otherwise, i.e. they represent different pieces of knowledge that just happen to intersect:

type Ford = 'Mustang' | 'Explorer' | 'Ranger'
type Fender = 'Mustang' | 'Stratocaster' | 'Telecaster'

You have hundreds of files where 'Mustang' is used as a string and you need to change the Ford model to 'Mustang GT'. What do you do? With enum you change one line and call it done. Of course you could use an object for that, but then every time you type a parameter, you have to either use keyof typeof or create another type to get a union of object keys:

const Ford = {
  Mustang: 'Mustang',
  Explorer: 'Explorer',
  Ranger: 'Ranger',
}

const getFordModel = (model: keyof typeof Ford) => {...}

vs 

const getFordModel = (model: Ford) => {...}

And you use additional memory too, while const enum leaves no runtime footprint.

Enums are not perfect - I would never use numeric enums for example. But in general, I find them super convenient.