Quando deve usar tipos e quando interfaces em…

Os tipos (type) devem ser usados para:

Uniões (unions) e interseções (intersections):

type Status = "pending" | "completed" | "failed";
type UserWithAddress = User & Address;

Tipos primitivos e literais:

type ID = string | number;
type Direction = "up" | "down" | "left" | "right";

Tuplos:

type RgbColor = [number, number, number];

Criação de aliases para tipos existentes:
```
type StringOrNumber = string | number;
```

Tipos condicionais:

type TypeOfProp<T, K extends keyof T> = T[K];

As interfaces (interface) devem ser usadas para:

Descrever a estrutura de objetos:

interface User {
  id: number;
  name: string;
  age?: number; // Propriedade opcional
}

Implementação por classes (implements):

interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string) {
    console.log(message);
  }
}

Extensão de outras interfaces (extends):

interface Person {
  name: string;
}

interface Employee extends Person {
  employeeId: number;
}

Fusão declarativa (declaration merging): Isto permite expandir uma interface existente ao declará-la novamente. Com tipos, isto não é possível.
```
interface Box {
  width: number;
}

interface Box { // Isto adicionará a propriedade height à interface Box
  height: number;
}
```

Resumo comparativo:

Característica	`type`	`interface`
Tipos união	Sim	Não
Tipos interseção	Sim	Não
Tipos primitivos/literais	Sim	Não
Tuplas	Sim	Não
Alias de tipos	Sim	Não
Tipos condicionais	Sim	Não
Descrição de objetos	Sim	Sim
Implementação com classes	Não	Sim
Extensão	Sim (usando `&`)	Sim (usando `extends`)
Fusão declarativa	Não	Sim

De modo geral, para descrever a estrutura de objetos, é preferível usar interface, pois eles se ajustam melhor à abordagem orientada a objetos e suportam fusão declarativa. Para tudo o resto, especialmente para combinações e criação de novos tipos a partir de tipos existentes, type é mais flexível.

Quando deve usar tipos e quando interfaces em TypeScript?