Fala @guilzms, tudo tranquilo?

Minha visão sobre Type e Interface

A respeito de qual "modelagem" utilizar em relação ao projeto, no curso que estou fazendo de typescript tive a seguinte visão sobre o uso do alias type e interface:

TYPE: Geralmente utilizado para criar um atalho (alias) para um tipo customizado. Utilizado em tipos primitivos (string, boolean, number...):

type Categorias = 'design' | 'codigo' | 'descod';

function pintarCategoria(categoria: Categorias) {
  if (categoria === 'design') {
    console.log('Pintar vermelho');
  } else if (categoria === 'codigo') {
    console.log('Pintar verde');
  } else if (categoria === 'descod') {
    console.log('Pintar roxo');
  }
}

INTERFACE: Geralmente são utilizadas para definirmos objetos, entretanto não possibilita renomear tipos primitivos.

interface InterfaceProduto {
    nome: string;
    preco: number;
    teclado: number;
}

function preencherDados(dados: InterfaceProduto) {
  document.body.innerHTML += `
  <div>
    <h2>${dados.nome}</h2>
    <p>R$ ${dados.preco}</p>
    <p>Inclui teclado: ${dados.teclado ? 'sim' : 'não'}</p>
  </div>
  `;
}

Um bom ponto de observação, é que quando você cria um alias type,você está criando um apelido e nada mais. O Type é do tipo fechado, onde não é possível criar diferentes "versões" do mesmo tipo, então sua repetição gerará um Erro de TS:

// TYPE
type Window = {
  title: string
}

type Window = {
  ts: TypeScriptAPI
}

 // Error: Duplicate identifier 'Window'.

Para realizar a adição de uma nova propriedade a um Type, seria necessário fazer o seguinte processo:

type TipoCarro = {
  rodas: number;
  portas: number;
};

type TipoCarroComPreco = TipoCarro & {
  preco: number;
};

const dado1: TipoCarroComPreco = {
  preco: 20000,
  rodas: 4,
  portas: 5,
};

Já a Interface é do tipo aberta, então a mesma possibilita adicionar ou alterar campos, e também extende-la apenas redeclarando a mesma :

// Redeclaração de campos
interface InterfaceCarro {
  rodas: number;
  portas: number;
}

interface InterfaceCarro {
  preco: number;
}

const dado2: InterfaceCarro = {
  preco: 20000,
  rodas: 4,
  portas: 5,
};

Conclusão

O Matheus Benites - PapoDe.Dev dá um excelente panorama sobre a utilização de types e Interface:

se precisamos declarar os tipos de uma classe e seus metodos utilizamos interface; se precisamos declarar os tipo das props de uma função usamos alias type; se precisar criar uma definição de tipo que será extendida por algo, nós usamos interface; se estamos criando um generic type para alguma funcionalidade, usamos interface.

Espero ter ajudado, até mais!

Fontes:

Matheus Benites - PapoDe.Dev Documentação - Curso de Typescript - Origamid

interface modeloInterface {
    dado: string;
}

class FornecedorUm {
    consumirApi(): modeloInterface {
        return {
            dado: 'oi'
        }
    }
}

class FornecedorDois {
    consumirApi(): modeloInterface {
        return {
            dado: 'tchau'
        }
    }
}

interface EmpresaCallback {
    doc: string
    razao: string
}

type BrasilAPITypes = {
  cnpj: string;
  razao_social: string;
};

interface GlobalInterface {
    formataPesquisaCnpj: (param: BrasilAPITypes) => EmpresaCallback
}

class ConsultaBrasilAPI implements GlobalInterface  {
    formataPesquisaCnpj(callbackApi: BrasilAPITypes): EmpresaCallback {
        return {
            doc: callbackApi.cnpj,
            razao: callbackApi.razao_social
         }
    }
}