¿Cuándo deberías usar tipos y cuándo interfaces en…

Los tipos (type) deben usarse para:

Uniones (unions) e intersecciones (intersections):

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

Tipos primitivos y literales:

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

Tuplas:

type RgbColor = [number, number, number];

Creación de alias para tipos existentes:
```
type StringOrNumber = string | number;
```

Tipos condicionales:

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

Las interfaces (interface) deben usarse para:

Describir la estructura de objetos:

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

Implementación mediante clases (implements):

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

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

Extensión de otras interfaces (extends):

interface Person {
  name: string;
}

interface Employee extends Person {
  employeeId: number;
}

Fusión declarativa (declaration merging): Esto permite ampliar una interfaz existente declarándola nuevamente. Con los tipos, esto no es posible.
```
interface Box {
  width: number;
}

interface Box { // Esto añadirá la propiedad height a la interfaz Box
  height: number;
}
```

Resumen comparativo:

Característica	`type`	`interface`
Tipos unión	Sí	No
Tipos intersección	Sí	No
Tipos primitivos/literales	Sí	No
Tuplas	Sí	No
Alias de tipos	Sí	No
Tipos condicionales	Sí	No
Descripción de objetos	Sí	Sí
Implementación con clases	No	Sí
Extensión	Sí (usando `&`)	Sí (usando `extends`)
Fusión declarativa	No	Sí

En general, para describir la estructura de objetos, es preferible usar interface, ya que se ajusta mejor al enfoque orientado a objetos y soporta la fusión declarativa. Para todo lo demás, especialmente para combinaciones y creación de nuevos tipos a partir de existentes, type es más flexible.

¿Cuándo deberías usar tipos y cuándo interfaces en TypeScript?