termo_core 0.1.12 → 0.1.14

package/dist/talk/rotas.js

@@ -0,0 +1,353 @@
+// Gerado pelo gerador do TermoCore (`cargo run -p gerador`). Não edite à mão: a próxima geração sobrescreve.
+import { chamar_servico, codificar_parametro_de_caminho } from "../base/requisicao.js";
+import { TERMO_TALK as SERVICO_DESTA_API } from "../base/servicos.js";
+/**
+ * Busca o link para baixar um anexo
+ *
+ * Devolve o anexo com `url_download`, o link assinado do TermoBucket, que vale 15 minutos. Só para quem participa da conversa do anexo (senão `404`).
+ *
+ * `GET /anexo/{id}`
+ */
+export function buscar_pelo_id_anexo(credencial_de_acesso, id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "GET",
+        caminho_da_rota: `/anexo/${codificar_parametro_de_caminho(id)}`,
+        credencial_de_acesso,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Lista as conversas de quem pediu
+ *
+ * Todas as conversas (diretas, grupos e espaços) de que a pessoa participa: as fixadas primeiro e depois pela última atividade. Cada uma traz a prévia da última mensagem, o estado da pessoa (`eu`), as não lidas (`nao_lidas`, mensagens principais de outras pessoas depois da última lida, até 100) e as menções (`mencoes`). Na direta e no grupo vêm os participantes; no espaço, só o total. `busca` procura no nome da conversa e no nome dos participantes; `tipo` filtra por `DIRETA`, `GRUPO` ou `ESPACO`.
+ *
+ * `GET /conversa`
+ */
+export function buscar_pelo_filtro_conversa(credencial_de_acesso, parametros = {}, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "GET",
+        caminho_da_rota: "/conversa",
+        credencial_de_acesso,
+        parametros_de_consulta: parametros,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Cria uma conversa
+ *
+ * Livre para todo colaborador logado; quem cria entra sozinho. `DIRETA`: exatamente uma pessoa em `participante_ids`; se o par já tem conversa, devolve a que existe com `200`. `GRUPO`: uma ou mais pessoas (até 50 no total), `nome` opcional. `ESPACO`: `nome` obrigatório (até 80 caracteres), `descricao` até 1000, `visibilidade` `PUBLICO` (padrão, qualquer colaborador acha em explorar e entra) ou `PRIVADO` (só por convite); quem cria vira gestor. As mensagens chegam em tempo real em `GET /ws?token=<JWT>` (WebSocket com eventos JSON: `mensagem.criada`, `mensagem.atualizada`, `conversa.atualizada`, `conversa.removida`, `conversa.lida`, `digitando`, `presenca` e `presenca.inicial`).
+ *
+ * `POST /conversa`
+ */
+export function criar_conversa(credencial_de_acesso, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: "/conversa",
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Lista os espaços públicos para entrar
+ *
+ * Espaços `PUBLICO` em que a pessoa ainda não está, em ordem alfabética (até 200). `busca` procura no nome e na descrição.
+ *
+ * `GET /conversa/explorar`
+ */
+export function explorar_conversa(credencial_de_acesso, parametros = {}, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "GET",
+        caminho_da_rota: "/conversa/explorar",
+        credencial_de_acesso,
+        parametros_de_consulta: parametros,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Busca colaboradores para conversar
+ *
+ * Colaboradores ativos (até 30), em ordem alfabética, para começar uma conversa ou chamar para um grupo ou espaço. `busca` procura no nome, no e-mail, no setor e no cargo.
+ *
+ * `GET /conversa/pessoas`
+ */
+export function buscar_pessoas_conversa(credencial_de_acesso, parametros = {}, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "GET",
+        caminho_da_rota: "/conversa/pessoas",
+        credencial_de_acesso,
+        parametros_de_consulta: parametros,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Busca uma conversa pelo id
+ *
+ * A conversa com todos os participantes (inclusive no espaço), o papel de cada um e o estado de quem pediu.
+ *
+ * `GET /conversa/{id}`
+ */
+export function buscar_pelo_id_conversa(credencial_de_acesso, id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "GET",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}`,
+        credencial_de_acesso,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Atualiza o nome, a descrição ou a visibilidade
+ *
+ * No grupo, qualquer participante muda o `nome`. No espaço, só os gestores mudam `nome`, `descricao` (`null` apaga) e `visibilidade`. A conversa direta não tem nome (`400`).
+ *
+ * `PATCH /conversa/{id}`
+ */
+export function atualizar_pelo_id_conversa(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "PATCH",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Exclui o espaço ou o grupo
+ *
+ * O espaço, só os gestores; o grupo, só quem criou. A conversa direta não se exclui (`400`). Todos os participantes recebem `conversa.removida`.
+ *
+ * `DELETE /conversa/{id}`
+ */
+export function deletar_pelo_id_conversa(credencial_de_acesso, id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "DELETE",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}`,
+        credencial_de_acesso,
+        formato_da_resposta: "sem_conteudo",
+    }, opcoes_da_chamada);
+}
+/**
+ * Envia um arquivo para uma mensagem
+ *
+ * Quem participa da conversa envia o arquivo (`conteudo` em base64, até 20 MB; `nome` com a extensão e `tipo` MIME). O arquivo vai direto ao TermoBucket como arquivo privado e nunca fica no banco; se o bucket falhar, responde `503`. O `id` devolvido vai em `anexo_ids` do `POST /conversa/{id}/mensagem` (até 10 por mensagem; o texto pode ficar vazio). Os tipos aceitos são os liberados no cadastro do app no TermoBucket.
+ *
+ * `POST /conversa/{id}/anexo`
+ */
+export function enviar_anexo(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/anexo`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Entra num espaço público
+ *
+ * A pessoa entra como membro. Espaço privado ou outra conversa responde `404`. Repetir não muda nada.
+ *
+ * `POST /conversa/{id}/entrar`
+ */
+export function entrar_conversa(credencial_de_acesso, id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/entrar`,
+        credencial_de_acesso,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Marca a conversa como lida
+ *
+ * Marca como lida até `mensagem_id`; a leitura nunca volta para trás. As outras abas da pessoa recebem `conversa.lida`.
+ *
+ * `POST /conversa/{id}/lida`
+ */
+export function marcar_lida_conversa(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/lida`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Lista o histórico da conversa
+ *
+ * 50 mensagens por página, da mais antiga para a mais recente. Sem parâmetro, as últimas; `antes` traz as anteriores a uma mensagem (`tem_mais` diz se há mais); `depois` traz as que chegaram depois de uma (reconexão). Sem `thread_id`, só as mensagens principais (cada uma com `respostas`); com `thread_id`, as respostas daquela thread e a principal em `raiz`.
+ *
+ * `GET /conversa/{id}/mensagem`
+ */
+export function buscar_paginador_mensagem(credencial_de_acesso, id, parametros = {}, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "GET",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/mensagem`,
+        credencial_de_acesso,
+        parametros_de_consulta: parametros,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Envia uma mensagem
+ *
+ * `texto` obrigatório (até 10000 caracteres, com `*negrito*`, `_itálico_`, `~riscado~` e `` `código` ``). `thread_id` responde na thread de uma mensagem principal. `anexo_ids` liga arquivos já enviados em `POST /conversa/{id}/anexo` (até 10; com anexos o texto pode ficar vazio). `mencoes` são os ids citados com `@nome` (quem não está na conversa fica de fora) e `mencao_todos` cita `@todos`. Quem está conectado recebe `mensagem.criada` na hora (e, na resposta de thread, `mensagem.atualizada` com a principal).
+ *
+ * `POST /conversa/{id}/mensagem`
+ */
+export function criar_mensagem(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/mensagem`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Chama pessoas para o grupo ou o espaço
+ *
+ * Qualquer participante chama; quem já está continua como estava. A conversa direta não ganha pessoas (`400`): crie um grupo. O grupo vai até 50 pessoas.
+ *
+ * `POST /conversa/{id}/participante`
+ */
+export function adicionar_participantes_conversa(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/participante`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Muda o papel de alguém no espaço
+ *
+ * Só os gestores, só no espaço. `papel` é `GESTOR` ou `MEMBRO`; o espaço nunca fica sem gestor (`400`).
+ *
+ * `PATCH /conversa/{id}/participante/{colaborador_id}`
+ */
+export function atualizar_participante_conversa(credencial_de_acesso, id, colaborador_id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "PATCH",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/participante/${codificar_parametro_de_caminho(colaborador_id)}`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Tira alguém do grupo ou do espaço
+ *
+ * No grupo, qualquer participante; no espaço, só os gestores. Para sair, use `/sair`. A pessoa tirada recebe `conversa.removida`.
+ *
+ * `DELETE /conversa/{id}/participante/{colaborador_id}`
+ */
+export function remover_participante_conversa(credencial_de_acesso, id, colaborador_id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "DELETE",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/participante/${codificar_parametro_de_caminho(colaborador_id)}`,
+        credencial_de_acesso,
+        formato_da_resposta: "sem_conteudo",
+    }, opcoes_da_chamada);
+}
+/**
+ * Silencia ou fixa a conversa
+ *
+ * Só para quem pediu: `silenciado` (sem notificação, a não ser que citem a pessoa) e `fixado` (fica em cima na lista).
+ *
+ * `PATCH /conversa/{id}/preferencias`
+ */
+export function atualizar_preferencias_conversa(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "PATCH",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/preferencias`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Sai do grupo ou do espaço
+ *
+ * Da conversa direta não se sai (`400`). Se sair o último gestor do espaço, quem está há mais tempo vira gestor.
+ *
+ * `POST /conversa/{id}/sair`
+ */
+export function sair_conversa(credencial_de_acesso, id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/conversa/${codificar_parametro_de_caminho(id)}/sair`,
+        credencial_de_acesso,
+        formato_da_resposta: "sem_conteudo",
+    }, opcoes_da_chamada);
+}
+/**
+ * Edita uma mensagem
+ *
+ * Só quem escreveu. Troca o `texto` (e, se vierem, as citações) e marca `editado_em`.
+ *
+ * `PATCH /mensagem/{id}`
+ */
+export function atualizar_pelo_id_mensagem(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "PATCH",
+        caminho_da_rota: `/mensagem/${codificar_parametro_de_caminho(id)}`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}
+/**
+ * Exclui uma mensagem
+ *
+ * Quem escreveu, ou um gestor do espaço. A principal com respostas fica no lugar como excluída, sem texto.
+ *
+ * `DELETE /mensagem/{id}`
+ */
+export function deletar_pelo_id_mensagem(credencial_de_acesso, id, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "DELETE",
+        caminho_da_rota: `/mensagem/${codificar_parametro_de_caminho(id)}`,
+        credencial_de_acesso,
+        formato_da_resposta: "sem_conteudo",
+    }, opcoes_da_chamada);
+}
+/**
+ * Reage a uma mensagem
+ *
+ * Põe a reação de quem pediu com o `emoji`; reagir de novo com o mesmo tira.
+ *
+ * `POST /mensagem/{id}/reacao`
+ */
+export function reagir_mensagem(credencial_de_acesso, id, corpo_da_requisicao, opcoes_da_chamada) {
+    return chamar_servico({
+        servico: SERVICO_DESTA_API,
+        metodo_http: "POST",
+        caminho_da_rota: `/mensagem/${codificar_parametro_de_caminho(id)}/reacao`,
+        credencial_de_acesso,
+        corpo_json: corpo_da_requisicao,
+        formato_da_resposta: "json",
+    }, opcoes_da_chamada);
+}

package/dist/talk/tipos.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Os dados do anexo que vão junto da mensagem.
+ */
+export interface Anexo {
+    id: string;
+    nome: string;
+    /**
+     * Em bytes.
+     */
+    tamanho: number;
+    /**
+     * Tipo MIME (`image/png`, `application/pdf`...).
+     */
+    tipo: string;
+}
+export interface AnexoComEndereco {
+    id: string;
+    nome: string;
+    tamanho: number;
+    tipo: string;
+    /**
+     * Link assinado do TermoBucket; vale 15 minutos.
+     */
+    url_download: string;
+}
+export interface AnexoEnviar {
+    /**
+     * O arquivo em base64 (até 20 MB depois de decodificado).
+     */
+    conteudo: string;
+    /**
+     * Nome do arquivo, com a extensão.
+     */
+    nome: string;
+    /**
+     * Tipo MIME.
+     */
+    tipo: string;
+}
+/**
+ * Colaborador para escolher numa conversa: nome, e-mail, setor e cargo.
+ */
+export interface ColaboradorPessoa {
+    cargo?: string | null;
+    email: string;
+    id: string;
+    nome: string;
+    setor?: string | null;
+}
+/**
+ * Resumo do colaborador (id e nome) para mostrar autoria.
+ */
+export interface ColaboradorResumo {
+    id: string;
+    nome: string;
+}
+export interface Conversa {
+    criado_em: string;
+    criado_por: string;
+    descricao?: string | null;
+    eu?: MeuEstado | null;
+    id: string;
+    /**
+     * Mensagens que citam quem pediu (ou `@todos`) depois da última lida, inclusive nas threads.
+     */
+    mencoes: number;
+    /**
+     * Mensagens principais (fora das threads) de outras pessoas depois da última lida.
+     */
+    nao_lidas: number;
+    nome?: string | null;
+    /**
+     * Na conversa direta e no grupo vêm todos; no espaço, só na leitura pelo id.
+     */
+    participantes: Array<Participante>;
+    /**
+     * `DIRETA`, `GRUPO` ou `ESPACO`.
+     */
+    tipo: string;
+    total_participantes: number;
+    ultima_atividade_em: string;
+    ultima_mensagem?: UltimaMensagem | null;
+    /**
+     * Só no espaço: `PUBLICO` (qualquer colaborador acha e entra) ou `PRIVADO` (só por convite).
+     */
+    visibilidade?: string | null;
+}
+export interface ConversaAtualizar {
+    descricao?: string | null;
+    nome?: string | null;
+    visibilidade?: string | null;
+}
+export interface ConversaCriar {
+    descricao?: string | null;
+    /**
+     * Obrigatório no espaço; opcional no grupo; ignorado na conversa direta.
+     */
+    nome?: string | null;
+    /**
+     * As outras pessoas (quem cria entra sozinho). Na direta, exatamente uma.
+     */
+    participante_ids?: Array<string>;
+    /**
+     * `DIRETA`, `GRUPO` ou `ESPACO`.
+     */
+    tipo: string;
+    /**
+     * Só no espaço: `PUBLICO` (padrão) ou `PRIVADO`.
+     */
+    visibilidade?: string | null;
+}
+export interface EspacoPublico {
+    descricao?: string | null;
+    id: string;
+    nome: string;
+    total_participantes: number;
+    ultima_atividade_em: string;
+}
+export interface LeituraMarcar {
+    /**
+     * A última mensagem vista; a leitura nunca volta para trás.
+     */
+    mensagem_id: string;
+}
+export interface Mensagem {
+    /**
+     * Arquivos e imagens; o link para baixar vem de `GET /anexo/{id}`.
+     */
+    anexos: Array<Anexo>;
+    autor: ColaboradorResumo;
+    conversa_id: string;
+    criado_em: string;
+    editado_em?: string | null;
+    /**
+     * Mensagem principal excluída que ainda tem respostas: fica no lugar, sem texto.
+     */
+    excluida: boolean;
+    id: string;
+    mencao_todos: boolean;
+    mencoes: Array<string>;
+    reacoes: Array<Reacao>;
+    respostas: number;
+    seguidores: Array<string>;
+    /**
+     * Texto com formatação simples (`*negrito*`, `_itálico_`, `~riscado~`, `` `código` ``); vazio se excluída.
+     */
+    texto: string;
+    /**
+     * A mensagem principal da thread; vazio na mensagem principal.
+     */
+    thread_id?: string | null;
+    ultima_resposta_em?: string | null;
+}
+export interface MensagemAtualizar {
+    mencao_todos?: boolean | null;
+    mencoes?: Array<string> | null;
+    texto: string;
+}
+export interface MensagemCriar {
+    /**
+     * Anexos já enviados em `POST /conversa/{id}/anexo` (até 10).
+     */
+    anexo_ids?: Array<string>;
+    /**
+     * Citou `@todos`.
+     */
+    mencao_todos?: boolean;
+    /**
+     * Quem foi citado com `@nome` (precisa estar na conversa).
+     */
+    mencoes?: Array<string>;
+    /**
+     * Pode ficar vazio quando vão anexos.
+     */
+    texto?: string;
+    /**
+     * Responde na thread desta mensagem principal.
+     */
+    thread_id?: string | null;
+}
+/**
+ * O estado de quem pediu numa conversa.
+ */
+export interface MeuEstado {
+    entrou_em: string;
+    fixado: boolean;
+    papel: string;
+    silenciado: boolean;
+    ultima_lida_id?: string | null;
+}
+export interface PaginaDeMensagens {
+    /**
+     * Da mais antiga para a mais recente.
+     */
+    itens: Array<Mensagem>;
+    raiz?: Mensagem | null;
+    /**
+     * Há mensagens mais antigas que as desta página.
+     */
+    tem_mais: boolean;
+}
+export interface Participante {
+    entrou_em: string;
+    id: string;
+    nome: string;
+    papel: string;
+}
+export interface ParticipanteAtualizar {
+    /**
+     * `GESTOR` ou `MEMBRO`.
+     */
+    papel: string;
+}
+export interface ParticipantesAdicionar {
+    colaborador_ids: Array<string>;
+}
+export interface PreferenciasAtualizar {
+    fixado?: boolean | null;
+    silenciado?: boolean | null;
+}
+export interface Reacao {
+    colaborador_ids: Array<string>;
+    emoji: string;
+}
+export interface ReacaoAlternar {
+    /**
+     * O emoji; reagir de novo com o mesmo tira a reação.
+     */
+    emoji: string;
+}
+export interface RespostaDeErro {
+    erro: string;
+}
+export interface UltimaMensagem {
+    autor: ColaboradorResumo;
+    criado_em: string;
+    id: string;
+    texto: string;
+}

package/dist/talk/tipos.js

@@ -0,0 +1,2 @@
+// Gerado pelo gerador do TermoCore (`cargo run -p gerador`). Não edite à mão: a próxima geração sobrescreve.
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termo_core",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Todos os clientes da Termotubos num pacote só: um módulo por serviço e cada rota da API como uma função com fetch, com o endereço resolvido pelo ambiente atual.",
   "license": "MIT",
   "author": "TI Termotubos <ti@termotubos.com.br>",