Muito boa essa definição! Gostei!

Após a leitura do material e das suas conclusões vejo que está parecido com a metodologia que estou aplicando atualmente onde:

• Parametros de métodos e funções: Type
• Classe, métodos e callbacks: Interface
• métodos e callbacks privados não repetidos em outras classes: Type

E quando digo sobre métodos repetidos me refiro a isto por exemplo:

interface modeloInterface {
    dado: string;
}

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

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

Nestes exemplos o retorno dado no método consumirApi precisa ser identico em todas as classes.

E o legal que vi em vários materiais, seu comentário e também o que estava pensando sobre os type é que eles são somente um alias enquanto que a interface, assim como em outras linguagens, é um contrato que deve ter seus parâmetros e métodos aplicados dentro da classe ou método onde ela é aplicada obrigatóriamente enquanto que o type não.

Além do exemplo que citei no post original eu poderia implementar esse nível de interfaces também diretamente na classe.

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
         }
    }
}

Mas essa modelagem no meu caso eu preferi não seguir porque a classe em si é modelo "único" e não vai se repetir enquanto que o meu método formataPesquisaCnpj poderá se repetir em outra classe que receberá dados de outra fonte e o callback delas devem ser identicos indiferente da fonte de dados. Além que quero evitar o "interfaces hell" em toda a aplicação assim como existia com o callback hell antes do async/await hahaha :-D

Pelo que estou vendo de acordo com os comentários, alguns materiais, troca de experiências e o pouco que tenho de conhecimento é que não existe muito bem denifino do Typescript um "manual de boas práticas" sobre uso de interfaces diferentemente de outras linguagens.