snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/send-emails-from-workflows.mdx

@@ -0,0 +1,167 @@
+---
+title: Enviar e-mails a partir de Fluxos de Trabalho
+description: Envie e-mails personalizados automaticamente usando ações de Fluxos de Trabalho.
+---
+
+Envie e-mails automaticamente quando eventos específicos ocorrerem no seu CRM — dê boas-vindas a novos contatos, faça acompanhamento de oportunidades ou notifique membros da equipe.
+
+## Pré-requisitos
+
+Antes de enviar e-mails a partir de fluxos de trabalho:
+
+1. Conecte uma conta de e-mail em **Configurações → Contas**
+2. Garanta que a conta tenha as permissões de envio ativadas
+
+## Fluxo de Trabalho de E-mail Básico
+
+### Exemplo: E-mail de boas-vindas para novos contatos
+
+**Objetivo**: Enviar um e-mail de boas-vindas quando uma nova pessoa for adicionada ao CRM.
+
+**Configuração**:
+
+1. **Criar fluxo de trabalho**: Vá até **Configurações → Fluxos de Trabalho** e clique em **+ Novo Fluxo de Trabalho**
+
+2. **Adicionar gatilho**: Selecione **Registro é Criado** → **Pessoas**
+
+3. **Adicionar ação Enviar E-mail**:
+   * Clique em **+** para adicionar uma ação
+   * Selecione **Enviar E-mail**
+   * Configure o e-mail:
+
+| Campo       | Valor                                  |
+| ----------- | -------------------------------------- |
+| **Para**    | `{{trigger.object.email}}`             |
+| **Assunto** | `Bem-vindo ao {{Your Company Name}}`   |
+| **Corpo**   | `Hi {{trigger.object.firstName}}, ...` |
+
+4. **Testar e ativar**: Teste com um registro de exemplo e, em seguida, ative
+
+## Usando variáveis em e-mails
+
+Referencie dados de etapas anteriores usando a sintaxe `{{variable}}`:
+
+```text
+Hi {{trigger.object.firstName}},
+
+Thank you for connecting with us!
+
+Your company, {{trigger.object.company.name}}, is now in our system.
+
+Best regards,
+The Team
+```
+
+### Variáveis disponíveis dos gatilhos
+
+| Tipo de Trigger                | Variáveis comuns                       |
+| ------------------------------ | -------------------------------------- |
+| **Registro Criado/Atualizado** | `{{trigger.object.fieldName}}`         |
+| **Manual**                     | `{{trigger.selectedRecord.fieldName}}` |
+| **Webhook**                    | `{{trigger.body.fieldName}}`           |
+
+## Avançado: E-mails condicionais
+
+### Exemplo: E-mails diferentes com base na origem do lead
+
+**Objetivo**: Enviar e-mails de boas-vindas diferentes com base na origem do lead.
+
+**Configuração**:
+
+1. **Gatilho**: Registro é Criado (Pessoas)
+
+2. **Adicionar ação de Filtro**:
+   * Condição: `{{trigger.object.source}}` é igual a `"Website"`
+   * Se verdadeiro → continue para o e-mail de boas-vindas do site
+
+3. **Ramificação para outras origens**:
+   * Crie ramificações paralelas para origens diferentes
+   * Cada ramificação tem sua própria ação Enviar E-mail
+
+## Envio de e-mails para vários destinatários
+
+### Exemplo: Notificar a equipe quando o negócio for fechado
+
+**Objetivo**: Enviar e-mail ao representante de vendas e ao seu gerente quando uma oportunidade for ganha.
+
+**Configuração**:
+
+1. **Gatilho**: Registro é Atualizado (Oportunidades, Estágio = "Closed Won")
+
+2. **Pesquisar Registros**: Encontre o gerente do proprietário da oportunidade
+
+3. **Enviar E-mail nº 1**: Para o proprietário da oportunidade
+   * Para: `{{trigger.object.owner.email}}`
+   * Assunto: `Congratulations on closing {{trigger.object.name}}!`
+
+4. **Enviar E-mail nº 2**: Para o gerente
+   * Para: `{{searchRecords.manager.email}}`
+   * Assunto: `Deal Won: {{trigger.object.name}}`
+
+## E-mails de acompanhamento agendados
+
+### Exemplo: Acompanhar 3 dias após a reunião
+
+**Objetivo**: Enviar um e-mail de acompanhamento 3 dias após o registro de uma reunião.
+
+**Configuração**:
+
+1. **Gatilho**: Registro é Criado (Atividades, Tipo = "Reunião")
+
+2. **Ação de atraso**: Aguarde 3 dias
+
+3. **Enviar E-mail**:
+   * Para: Participante da reunião
+   * Assunto: Acompanhamento da nossa conversa
+   * Corpo: Referencie detalhes da reunião a partir do gatilho
+
+## Anexos de e-mail
+
+Você pode anexar arquivos a e-mails enviados a partir de fluxos de trabalho. O anexo é um arquivo estático que você faz upload ao configurar o fluxo de trabalho.
+
+### Como adicionar um anexo
+
+1. Na ação **Enviar e-mail**, clique no botão **Anexos**
+2. Clique para fazer upload de um arquivo do seu computador
+3. O arquivo será anexado a todos os e-mails enviados por esta ação
+
+### Casos de Uso Comuns
+
+| Caso de uso                   | Arquivo de exemplo                      |
+| ----------------------------- | --------------------------------------- |
+| **E-mails de boas-vindas**    | Brochura da empresa (PDF)               |
+| **Sequências de integração**  | Guia de primeiros passos                |
+| **Acompanhamentos de Vendas** | Catálogo de produtos ou lista de preços |
+| **Confirmações de evento**    | Detalhes ou agenda do evento            |
+
+<Note>
+Os anexos são estáticos — o mesmo arquivo é enviado a todos os destinatários. Para documentos dinâmicos (como cotações personalizadas), gere e anexe arquivos usando uma [Função Lógica](/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty).
+</Note>
+
+## Melhores Práticas
+
+### Conteúdo do e-mail
+
+* Mantenha as linhas de assunto concisas e relevantes
+* Personalize com o nome do destinatário
+* Inclua uma chamada para ação clara
+* Teste os e-mails antes de ativar
+
+### Entregabilidade
+
+* Não envie muitos e-mails muito rapidamente
+* Use assinaturas de e-mail profissionais
+* Evite palavras que acionem spam
+* Garanta opções de cancelamento de inscrição para e-mails de marketing
+
+### Resolução de Problemas
+
+* Verifique se a conta de e-mail está conectada e ativa
+* Verifique se o endereço de e-mail do destinatário é válido
+* Revise as execuções do fluxo de trabalho em busca de mensagens de erro
+* Teste primeiro com o seu próprio endereço de e-mail
+
+## Relacionados
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/use-branches-in-workflows.mdx

@@ -0,0 +1,88 @@
+---
+title: Use ramificações em fluxos de trabalho
+description: Entenda como as ramificações funcionam e como controlar qual caminho é executado.
+---
+
+## Como as ramificações funcionam
+
+No editor de fluxos de trabalho, você pode criar vários caminhos (ramificações) saindo de um único nó. Isso permite criar automações complexas com resultados diferentes.
+
+**Importante**: Quando um fluxo de trabalho é executado, **todas as ramificações são executadas em paralelo por padrão**. Não há lógica "if/else" integrada para escolher uma ramificação em vez de outra — todos os caminhos serão executados simultaneamente.
+
+## Controlando qual ramificação é executada
+
+Para executar apenas uma ramificação com base em condições específicas, **adicione um nó Filter no início de cada ramificação**.
+
+### Exemplo de configuração
+
+1. Crie seu fluxo de trabalho com várias ramificações a partir de um único nó
+2. Adicione um nó **Filter** como a primeira etapa de cada ramificação
+3. Defina condições em cada Filter para determinar quando essa ramificação deve continuar
+4. Somente as ramificações cujas condições do Filter forem atendidas prosseguirão
+
+### Como funcionam os nós Filter
+
+* Se a condição do Filter for **atendida**: A ramificação continua em execução
+* Se a condição do Filter **não for atendida**: A ramificação para no nó Filter
+
+Isso efetivamente cria uma lógica condicional em que apenas a ramificação apropriada é executada com base nos seus dados.
+
+## Exemplo: Roteamento por tamanho do negócio
+
+**Cenário**: Quando um negócio é fechado, envie notificações diferentes com base no tamanho do negócio.
+
+1. **Gatilho**: Oportunidade atualizada (Estágio = Closed Won)
+2. **Ramificação 1**: Filter para Amount > $10,000 → Enviar mensagem no Slack para #big-deals
+3. **Ramificação 2**: Filter para Amount ≤ $10,000 → Enviar e-mail para o gerente de vendas
+
+Ambas as ramificações iniciam, mas somente aquela que corresponder ao valor do negócio continuará além do seu Filter.
+
+## Criando ramificações
+
+<Note>
+Para criar uma nova ramificação a partir de uma etapa existente, clique no botão **+** na etapa e adicione sua ação. Você pode adicionar várias ramificações clicando em **+** várias vezes.
+</Note>
+
+1. No editor de fluxos de trabalho, selecione a etapa a partir da qual deseja ramificar
+2. Clique no botão **+** para adicionar uma ação
+3. Isso cria uma ramificação
+4. Clique em **+** novamente na mesma etapa para criar ramificações adicionais
+5. Cada ramificação pode ter sua própria sequência de ações
+
+## Unindo ramificações novamente
+
+Depois que as ramificações paralelas concluírem seu trabalho, você pode uní-las novamente em um único caminho:
+
+1. Conclua suas ações ramificadas
+2. Adicione uma nova etapa que deve ser executada após todas as ramificações
+3. Arraste uma conexão da última etapa de cada ramificação para essa nova etapa
+4. A etapa unificada aguarda todas as ramificações conectadas concluírem antes de ser executada
+
+### Exemplo: Processar e depois notificar
+
+```
+Trigger
+   │
+   ├── Branch A: Update Customer Record
+   │
+   └── Branch B: Create Support Ticket
+
+       ↘  ↙
+
+   Merged Step: Send Confirmation Email
+```
+
+O e-mail de confirmação é enviado apenas após a atualização do cliente e a criação do bilhete ser feita.
+
+## Melhores Práticas
+
+* Sempre use **nós Filter** no início das ramificações quando quiser execução condicional
+* Mantenha as condições das ramificações **mutuamente exclusivas** para evitar ações duplicadas
+* Teste seus fluxos de trabalho com dados diferentes para garantir que as ramificações corretas sejam executadas
+* **Renomeie as etapas das ramificações** de forma descritiva para que fique claro o que cada caminho faz
+* **Una as ramificações** quando precisar de uma ação final após o processamento em paralelo
+
+## Relacionados
+
+* [Perguntas frequentes sobre fluxos de trabalho](/l/pt/user-guide/workflows/how-tos/need-more-help/workflows-faq) — respostas sobre execução paralela
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions) — ações disponíveis para ramificações

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/use-iterator.mdx

@@ -0,0 +1,183 @@
+---
+title: Usar Iterador
+description: Percorra arrays de registos para executar ações em cada item.
+---
+
+O Iterador permite percorrer um array de registos e executar ações em cada um. É essencial para fluxos de trabalho que precisam de processar vários registos devolvidos por Pesquisar Registos ou recebidos via Webhooks.
+
+## Quando usar o Iterador
+
+| Cenário                              | Exemplo                                          |
+| ------------------------------------ | ------------------------------------------------ |
+| **Processar resultados da pesquisa** | Enviar e-mail a cada pessoa encontrada           |
+| **Lidar com arrays de Webhooks**     | Criar registos para cada item por ordem          |
+| **Atualizações em massa**            | Atualizar vários registos com valores calculados |
+| **Notificações**                     | Alertar várias pessoas sobre um evento           |
+
+## Compreender o Iterador
+
+O Iterador espera um **array** como entrada. Em seguida:
+
+1. Obtém o primeiro item do array
+2. Executa todas as ações dentro do Iterador com esse item
+3. Passa para o item seguinte
+4. Repete até que todos os itens sejam processados
+
+### Selecionar o array para iterar
+
+A maioria das origens de arrays (Search Records, um campo de array de webhook, um gatilho manual em massa) pode ser selecionada diretamente no seletor de variáveis.
+
+Quando uma etapa de **Code** ou **Logic Function** retorna um *array de nível superior*, sua saída aparece no seletor de variáveis como entradas indexadas (`0`, `1`, `2`, …). Para iterar sobre o array como um todo, selecione a opção **Whole list** para essa etapa — o Iterator então deduz automaticamente o formato de cada item a partir da lista.
+
+## Configuração básica
+
+### Exemplo: Enviar e-mail a todos nos resultados da pesquisa
+
+**Objetivo**: Encontrar todos os contactos numa empresa específica e enviar a cada um um e-mail personalizado.
+
+### Etapa 1: Pesquisar registos
+
+1. Adicione a ação **Pesquisar Registos**
+2. Objeto: **Pessoas**
+3. Filtro: Empresa igual a "Acme Inc"
+4. Isto devolve um array de pessoas
+
+### Etapa 2: Verificar se existem resultados
+
+1. Adicione a ação **Filtro**
+2. Condição: `{{searchRecords.length}}` é maior do que 0
+3. Isto evita erros do Iterador em resultados vazios
+
+### Etapa 3: Adicionar um Iterador
+
+1. Adicione a ação **Iterador**
+2. Entrada do array: selecione `{{searchRecords}}`
+3. Isto cria um ciclo
+
+### Etapa 4: Adicionar ações dentro do Iterador
+
+As ações colocadas após o Iterador são executadas para cada item:
+
+1. Adicione a ação **Enviar e-mail** (dentro do Iterador)
+2. Para: `{{iterator.currentItem.email}}`
+3. Assunto: Olá `{{iterator.currentItem.firstName}}`!
+4. Corpo: Mensagem personalizada utilizando os campos do item atual
+
+### Resultado
+
+Se Pesquisar Registos devolver 5 pessoas, o Iterador:
+
+* Envia e-mail para a pessoa 1
+* Envia e-mail para a pessoa 2
+* ... continua para todas as 5
+
+## Aceder aos dados do item atual
+
+Dentro do Iterador, use `{{iterator.currentItem}}` para aceder ao registo atual:
+
+| Variável                                | Descrição                       |
+| --------------------------------------- | ------------------------------- |
+| `{{iterator.currentItem}}`              | Todo o objeto do registo atual  |
+| `{{iterator.currentItem.id}}`           | ID do registo                   |
+| `{{iterator.currentItem.email}}`        | Campo de e-mail                 |
+| `{{iterator.currentItem.company.name}}` | Nome da empresa relacionada     |
+| `{{iterator.index}}`                    | Posição atual no array (base 0) |
+
+No seletor de variáveis, você pode detalhar um campo específico do item atual ou escolher **Use the whole item** para fazer referência ao item atual inteiro (`{{iterator.currentItem}}`). Selecionar o item inteiro é útil quando você quer passar um registro completo diretamente para uma etapa subsequente, em vez de reconstruí-lo campo por campo.
+
+## Padrões comuns
+
+### Atualizar vários registos
+
+**Objetivo**: Marcar todas as tarefas em atraso como "Late"
+
+```
+1. Search Records (Tasks, Due Date < Today, Status ≠ Completed)
+2. Filter (length > 0)
+3. Iterator (searchRecords)
+   └── Update Record
+       - Object: Tasks
+       - Record: {{iterator.currentItem.id}}
+       - Status: Late
+```
+
+### Criar registos a partir de um array
+
+**Objetivo**: O Webhook recebe um pedido com vários itens, criar um registo para cada um
+
+```
+1. Webhook Trigger (receives items array)
+2. Filter (items.length > 0)
+3. Iterator (trigger.body.items)
+   └── Create Record
+       - Object: Order Items
+       - Name: {{iterator.currentItem.name}}
+       - Quantity: {{iterator.currentItem.qty}}
+       - Related Order: {{trigger.body.orderId}}
+```
+
+### Processamento condicional dentro do ciclo
+
+**Objetivo**: Enviar e-mail apenas para contactos com e-mails válidos
+
+```
+1. Search Records (People)
+2. Iterator (searchRecords)
+   └── Filter (currentItem.email is not empty)
+       └── Send Email
+           - To: {{iterator.currentItem.email}}
+```
+
+## Resolução de Problemas
+
+### "O Iterador espera um array"
+
+**Causa**: Passou um único registo em vez de um array.
+
+**Correção**: Certifique-se de que está a passar o resultado de Pesquisar Registos ou um campo do tipo array, e não um único registo.
+
+```
+✅ Correct: {{searchRecords}}
+❌ Wrong: {{searchRecords[0]}}
+```
+
+### O Iterador não é executado
+
+**Causa**: O array está vazio.
+
+**Correção**: Adicione um Filtro antes do Iterador para verificar o tamanho do array:
+
+```
+Filter: {{searchRecords.length}} > 0
+```
+
+### Ações executadas vezes demais
+
+**Causa**: Pesquisar Registos devolveu mais registos do que o esperado.
+
+**Correção**:
+
+* Adicione filtros mais específicos a Pesquisar Registos
+* Defina um limite em Pesquisar Registos (máx. 200)
+* Adicione um Filtro dentro do Iterador para condições adicionais
+
+## Considerações de desempenho
+
+* **Utilização de créditos**: Cada iteração consome créditos pelas suas ações
+* **Tempo**: Arrays grandes demoram mais a processar
+* **Limites**: Considere agrupar em lotes operações muito grandes
+* **Limites de taxa**: Chamadas a APIs externas podem atingir limites de taxa com muitas iterações
+
+## Melhores Práticas
+
+1. **Verifique sempre o tamanho do array** antes do Iterador para evitar erros
+2. **Adicione filtros dentro dos ciclos** quando nem todos os itens precisam de processamento
+3. **Renomeie a etapa do seu Iterador** para descrever o que está a percorrer
+4. **Teste com arrays pequenos** antes de processar conjuntos de dados grandes
+5. **Monitorize as execuções dos fluxos de trabalho** para garantir que as iterações se concluam conforme o esperado
+
+## Relacionados
+
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Como usar ramificações](/l/pt/user-guide/workflows/capabilities/use-branches-in-workflows)
+* [FAQ de Fluxos de Trabalho](/l/pt/user-guide/workflows/how-tos/need-more-help/workflows-faq)

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-actions.mdx

@@ -0,0 +1,332 @@
+---
+title: Ações de Fluxo de Trabalho
+description: Saiba mais sobre as ações disponíveis nos fluxos de trabalho do Twenty.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+## Sobre as Ações
+
+As ações definem o que acontece após um gatilho ser acionado. Você pode encadear várias ações para criar automações complexas.
+
+<Tip>
+* Use o seletor de variáveis (clique no ícone `(x+)`) para explorar os dados disponíveis de etapas anteriores
+* Passe o cursor sobre qualquer campo de entrada para ver de qual etapa uma variável vem — útil quando o mesmo campo (por exemplo, ID) existe em várias etapas anteriores
+* Dê a cada ação um nome descritivo para facilitar a manutenção
+</Tip>
+
+## Ações em Registros
+
+<img src="/images/user-guide/workflows/workflow_actions.png" style={{width:'100%'}} />
+
+### Criar Registro
+
+Adiciona um novo registro a um objeto selecionado.
+
+**Configuração**:
+
+* Selecione o objeto alvo
+* Preencha os campos obrigatórios e opcionais
+* Use dados de etapas anteriores ou insira valores manualmente para preencher os campos
+
+**Saída**: Os dados do registro recém-criado estão disponíveis para uso em etapas subsequentes.
+
+### Atualizar Registro
+
+Modifica um registro existente em um objeto selecionado.
+
+<img src="/images/user-guide/workflows/update_record.png" style={{width:'100%'}} />
+
+**Configuração**:
+
+* Selecione o objeto alvo
+* Escolha o registro específico para atualizar.
+  * Você pode escolher um registro fixo, usando o menu suspenso que exibe todos os registros disponíveis.
+  * Ou você pode fazer com que o registro seja selecionado dinamicamente, designando um registro encontrado em uma etapa anterior, usando o `(x+)`. Você não pode pesquisar o registro com base em critérios diferentes nesta etapa. Se você ainda não identificou o registro, adicione uma etapa `Search Record` antes desta etapa `Update Record`.
+* Selecione campos para modificar e insira novos valores
+
+**Saída**: Os dados do registro atualizado estão disponíveis para uso em etapas subsequentes.
+
+### Excluir Registro
+
+Remove um registro de um objeto selecionado.
+
+**Configuração**:
+
+* Selecione o objeto alvo
+* Escolha o registro específico para excluir
+
+**Saída**: Os dados do registro excluído permanecem disponíveis para uso em etapas subsequentes.
+
+### Pesquisar Registros
+
+Encontra registros dentro de um objeto selecionado usando condições de filtro.
+
+**Configuração**:
+
+* Selecione o objeto para pesquisar
+* Defina critérios de filtro para restringir os resultados
+* Configurar ordenação e limites
+
+**Saída**: Retorna registros correspondentes que podem ser usados em etapas subsequentes.
+
+<Note>
+**Limite**: Search Records retorna no máximo **200 registros**. Se você precisar processar mais, adicione filtros específicos para reduzir os resultados ou use fluxos de trabalho agendados para processar em lotes.
+</Note>
+
+**Melhor prática**: Use [ramificações](/l/pt/user-guide/workflows/capabilities/workflow-branches) após Search Records para lidar com os cenários "encontrado" vs "não encontrado".
+
+### Upsert Record
+
+Cria um novo registro ou atualiza um existente com base em critérios de correspondência. Isso é útil quando você não tem certeza se um registro já existe.
+
+<img src="/images/user-guide/workflows/upsert_double_identifier.png" style={{width:'100%'}} />
+
+**Configuração**:
+
+* Selecione o objeto alvo
+* Observe quais campos podem ser usados para correspondência: e-mail para Pessoas, domínio para Empresas, ID para qualquer objeto ou qualquer campo marcado como Único. Você precisará preencher pelo menos um destes abaixo.
+* Preencha os valores dos campos. Não se esqueça de preencher pelo menos um dos identificadores únicos.
+
+<Note>
+**A correspondência geralmente funciona ainda melhor ao adicionar apenas um identificador único.** Por exemplo, a captura de tela abaixo fará a correspondência de empresas com base no domínio delas. O ID não é necessariamente obrigatório.
+</Note>
+
+<img src="/images/user-guide/workflows/upsert_simple_identifier.png" style={{width:'100%'}} />
+
+* Use dados de etapas anteriores para preencher os campos
+
+**Como Funciona**:
+
+1. Procura um registro que corresponda aos seus critérios
+2. Se encontrado → atualiza o registro existente
+3. Se não encontrado → cria um novo registro
+
+**Saída**: Os dados do registro criado ou atualizado estão disponíveis para uso em etapas subsequentes.
+
+## Ações de Fluxo
+
+### Iterador
+
+**Percorre um array de registros** retornados de uma etapa anterior, permitindo que você execute ações em cada registro individualmente.
+
+**Configuração**:
+
+* Selecione o array de registros de uma etapa anterior (por exemplo, resultados de Search Records, de um gatilho manual com disponibilidade em lote ou de um nó de código). Quando uma etapa de código ou de função lógica retorna um array de nível superior, selecione a opção **Whole list** para iterar por toda a saída.
+* Defina as ações a serem realizadas em cada registro no loop.
+
+<Note>
+- Você pode adicionar várias ações dentro de um iterador.
+- Ao usar ramificações dentro de um iterador, certifique-se de que a última etapa de cada ramificação se conecte de volta ao iterador para fechar o loop.
+</Note>
+
+* Acesse os campos de `Current Item`: para usar campos do registro que está sendo processado no momento, clique na etapa **Iterator** e, em seguida, selecione **Current item**. A lista de campos disponíveis desse registro será exibida e poderá ser selecionada para uso em ações subsequentes. Você também pode selecionar **Use the whole item** para passar o item atual inteiro para uma etapa posterior.
+
+<VimeoEmbed videoId="1146577247" title="Demonstração em vídeo" />
+
+### Filtro
+
+Filtra registros com base em condições especificadas, permitindo que apenas os registros que atendam aos critérios passem.
+
+**Configuração**:
+
+* Selecione o registro a ser filtrado
+* Defina condições e critérios de filtro
+* Configure quais registros devem passar para as etapas subsequentes
+
+<Note>
+1. **Saída**: Nós de filtro não retornam dados — eles atuam como portões. Se as condições forem atendidas, o fluxo de trabalho continua. Caso contrário, o fluxo de trabalho para nessa ramificação.
+2. O operador `IS` pode ser usado com campos numéricos. Ele funciona como um `EQUAL`.
+</Note>
+
+### Atraso
+
+Pausa a execução do fluxo de trabalho por uma duração especificada ou até uma data/hora específica.
+
+**Tipos de Atraso**:
+
+| Tipo                | Descrição                                                               |
+| ------------------- | ----------------------------------------------------------------------- |
+| **Duração**         | Aguarda um período específico de tempo (dias, horas, minutos, segundos) |
+| **Data Programada** | Aguarda até uma data e hora específicas                                 |
+
+**Configuração para Duração**:
+
+* Defina dias, horas, minutos e/ou segundos
+* Combine várias unidades (por exemplo, 2 dias e 4 horas)
+
+**Configuração para Data Programada**:
+
+* Selecione uma data e hora
+* Pode referenciar um campo de data de uma etapa anterior (por exemplo, fazer um acompanhamento 3 dias após uma reunião)
+
+**Casos de uso**:
+
+* Aguarde 24 horas antes de enviar um e-mail de acompanhamento
+* Aguarde até a data de fechamento de uma oportunidade
+* Agende ações para o horário comercial
+
+<Note>
+A data programada não pode estar no passado. Se for usado um campo de data de uma etapa anterior e a data já tiver passado, o fluxo de trabalho falhará.
+</Note>
+
+**Limites e Créditos**:
+
+* **Sem limite máximo de duração** — você pode definir atrasos de minutos, dias, semanas ou mais longos
+* **1 crédito consumido** quando o nó de Atraso é executado, independentemente da duração
+* **Nenhum crédito consumido** durante a espera — um atraso de 5 minutos custa o mesmo que um atraso de 5 dias
+
+## Ações de Comunicação
+
+### Enviar Email
+
+Envia um email a partir do seu fluxo de trabalho. Isso é ótimo para e-mails de grupo com modelos. Os e-mails terão a mesma aparência dos que você envia da sua caixa de correio.
+Não é adequado para newsletters (que exigem formatação mais rica) ou sequências automáticas de e-mails.
+
+**Pré-requisitos**: Adicione uma conta de e-mail em Configurações → Contas
+
+**Configuração**:
+
+* Selecione a conta de e-mail do remetente
+
+<Note>
+Você só pode enviar e-mails de caixas de correio sincronizadas com a sua própria conta Twenty. O envio a partir das caixas de correio de outros membros da equipe (por exemplo, o e-mail do proprietário da conta) está no roadmap.
+</Note>
+
+Para todas as etapas a seguir, você pode referenciar variáveis de etapas anteriores para personalização.
+
+* Insira o endereço de email do destinatário.
+
+<Note>
+No momento, é possível apenas um destinatário.
+</Note>
+
+* Defina o assunto.
+* Componha o corpo da mensagem. Você pode formatar links, criar listas numeradas, listas com marcadores e adicionar anexos.
+
+<Note>
+Adicionar assinaturas em HTML não é possível no momento.
+</Note>
+
+### Formulário
+
+Apresenta um formulário durante a execução do fluxo de trabalho para coletar a entrada do usuário. As respostas podem então ser usadas em etapas subsequentes para criar registros, enviar e-mails ou executar qualquer outra ação com base na entrada.
+
+<Warning>
+**Os formulários são projetados apenas para gatilhos manuais**. Para fluxos de trabalho com outros gatilhos (Registro Criado, Atualizado, etc.), os formulários só são acessíveis via a interface de execução do fluxo de trabalho, o que não é a experiência esperada do usuário. Um centro de notificações será lançado em 2026 para suportar adequadamente os formulários em fluxos de trabalho automatizados.
+</Warning>
+
+**Configuração**:
+
+* Configure os campos que os usuários deverão preencher. Para cada campo, escolha
+  * um tipo entre texto, número, data, um determinado registro, um campo de seleção. Os campos de todos os objetos estão disponíveis para seleção.
+  * um rótulo
+  * um valor padrão em `Placeholder` (opcional)
+* Edite o título do formulário
+
+**Saída**: Respostas do formulário estão disponíveis para uso em etapas subsequentes.
+
+**Exemplo**: O fluxo de trabalho "Quick Lead" está disponível por padrão em todos os espaços de trabalho, disponível em qualquer lugar no Menu de Comando `Cmd+K`.
+
+**Como preencher o formulário**:
+
+* Acione seu fluxo de trabalho manual a partir do Menu de Comando `Cmd+K`
+* Preencha o formulário exibido no painel lateral e clique em `Submit`.
+
+<Note>
+Os campos não podem ser tornados obrigatórios.
+</Note>
+
+<VimeoEmbed videoId="1147277989" title="Demonstração em vídeo" />
+
+## Ações de Integração
+
+### Código
+
+Executa JavaScript personalizado dentro do seu fluxo de trabalho.
+
+Nos bastidores, cada ação de código é respaldada por sua própria **função lógica** — uma função TypeScript do lado do servidor que é executada na plataforma Twenty. Quando você adiciona uma ação de código, o Twenty cria uma função lógica dedicada para essa etapa e exibe seu editor em linha, de modo que o código que você escreve fica junto com o fluxo de trabalho.
+
+**Configuração**:
+
+* Acesse variáveis de etapas anteriores. Você pode editar os nomes das variáveis dinamicamente.
+
+<VimeoEmbed videoId="1147281795" title="Demonstração em vídeo" />
+
+* Escreva o código JavaScript no editor
+* Retorne variáveis para uso em etapas subsequentes
+* Teste o código diretamente na etapa
+
+<Note>
+Se você precisar usar chaves de API externas em seu código, deverá inseri-las diretamente no corpo da função. Você não pode configurar chaves de API em outro lugar e referenciá-las na função de lógica.
+</Note>
+
+<Tip>
+**Trabalhando com arrays?** Arrays de sistemas externos ou de etapas anteriores podem vir como strings. Veja [Como lidar com arrays em ações de código](/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions) para a solução.
+</Tip>
+
+<Tip>
+Clique no ícone quadrado no canto superior direito do editor de código para exibi-lo em tela cheia — útil, já que a largura padrão do editor é limitada.
+</Tip>
+
+#### Reutilizar uma função lógica em vários fluxos de trabalho
+
+A ação de código em linha é ótima para lógica pontual, mas o código que ela contém pertence apenas àquela etapa. Quando você quiser compartilhar a mesma lógica em vários fluxos de trabalho — ou mantê-la como código-fonte versionado em um aplicativo — defina uma **função lógica reutilizável** em vez de copiar e colar código em cada ação de código.
+
+Uma função lógica é definida uma vez em um aplicativo (usando o `defineLogicFunction` do SDK) e exposta ao construtor de fluxos de trabalho ao adicionar `workflowActionTriggerSettings`. Depois que seu aplicativo é instalado, essa função aparece como uma ação própria no construtor de fluxos de trabalho, ao lado das ações nativas. Ao selecioná-la, são renderizados os campos de entrada que você declarou (com seletores de variáveis, assim como outras ações) e o seu código compartilhado é executado — sem necessidade de JavaScript inline.
+
+|                        | Ação de código                                              | Função lógica reutilizável                                           |
+| ---------------------- | ----------------------------------------------------------- | -------------------------------------------------------------------- |
+| **Onde o código fica** | Editor em linha, vinculado a uma etapa do fluxo de trabalho | Definida em um app, versionada no controle de código-fonte           |
+| **Reutilização**       | Copiada e colada em cada etapa                              | Adicionada como uma ação em qualquer fluxo de trabalho               |
+| **Entradas**           | Variáveis conectadas no editor                              | Campos renderizados a partir do esquema de entrada que você declarou |
+| **Melhor para**        | Lógica rápida e específica do fluxo de trabalho             | Lógica compartilhada usada em vários fluxos de trabalho              |
+
+Ambas são executadas no mesmo tempo de execução da função lógica; portanto, uma ação de código que você prototipou em linha pode posteriormente ser promovida a uma função lógica reutilizável com mudanças mínimas.
+
+<Tip>
+Para a documentação de referência voltada para desenvolvedores sobre como definir funções lógicas e expô-las no construtor de fluxos de trabalho, consulte [Logic Functions](/l/pt/developers/extend/apps/logic/logic-functions) — em particular a seção **Exposing a function as an AI tool or workflow action** e `workflowActionTriggerSettings`.
+</Tip>
+
+### Requisição HTTP
+
+Envia uma solicitação para uma API externa como parte do seu fluxo de trabalho.
+
+<img src="/images/user-guide/workflows/http_action.png" style={{width:'100%'}} />
+
+**Configuração**:
+
+* Insira a URL do endpoint da API. É possível usar parâmetros de etapas anteriores.
+* Selecione o método HTTP (GET, POST, PUT, PATCH, DELETE)
+* Adicione cabeçalhos e valores obrigatórios
+* Forneça resposta de amostra para visualização da estrutura
+
+## Ações de IA
+
+### Agente de IA - Em breve
+
+Executa um agente de IA dentro do seu fluxo de trabalho para realizar tarefas inteligentes.
+
+**Configuração**:
+
+* **Agente**: Selecione um agente de IA existente ou use o agente padrão
+* **Prompt**: Escreva a instrução para o agente de IA
+* Referencie variáveis de etapas anteriores no prompt
+
+**O que os Agentes de IA podem fazer**:
+
+* Analisar e resumir dados
+* Classificar ou categorizar registros
+* Gerar conteúdo de texto
+* Tomar decisões com base em dados
+* Interagir com seus dados de CRM usando ferramentas
+
+**Saída**: A resposta do agente de IA está disponível para uso em etapas subsequentes. Se o agente tiver um esquema de saída estruturado, a resposta seguirá esse formato.
+
+<Note>
+As ações do Agente de IA consomem créditos de fluxo de trabalho com base no modelo de IA usado. Veja [Créditos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-credits) para obter detalhes.
+</Note>
+
+<Note>
+Os agentes de IA respeitam permissões baseadas em funções. Você pode atribuir funções específicas aos agentes em **Configurações → Membros → Funções** para controlar a quais dados eles podem acessar. Veja [Permissões](/l/pt/user-guide/permissions-access/capabilities/permissions) para obter detalhes.
+</Note>

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-branches.mdx

@@ -0,0 +1,66 @@
+---
+title: Ramificações de Fluxo de Trabalho
+description: Crie caminhos paralelos e lógica condicional em seus fluxos de trabalho.
+---
+
+As ramificações permitem dividir seu fluxo de trabalho em vários caminhos que podem ser executados simultaneamente ou condicionalmente com base em seus dados.
+
+<img src="/images/user-guide/workflows/branches.png" style={{width:'100%'}} />
+
+## Como as Ramificações Funcionam
+
+Quando você cria várias conexões a partir de um único nó, cada caminho se torna uma ramificação. Por padrão, **todas as ramificações são executadas em paralelo**—elas não esperam umas pelas outras.
+
+## Criando Ramificações
+
+### Adicionar uma Nova Ramificação
+
+1. **Clique com o botão direito na tela principal** do fluxo de trabalho (não em um nó existente)
+2. Clique em **Adicionar nó**
+3. Escolha o tipo de nó para sua nova ramificação
+4. Arraste uma seta da parte inferior da etapa anterior para o topo desta nova ação
+5. Repita para adicionar mais ramificações a partir do mesmo nó
+
+<Note>
+Cada ramificação é independente. Adicionar uma ramificação não afeta outros caminhos existentes desse nó.
+</Note>
+
+### Layout Visual
+
+As ramificações aparecem como caminhos paralelos no editor de fluxo de trabalho. Você pode arrastar nós para reorganizar o layout visual sem afetar a execução.
+
+## Ramificações Condicionais
+
+Como todas as ramificações são executadas por padrão, use nós **Filtro** para controlar quais caminhos realmente serão executados:
+
+| Ramificação | Condição de Filtro   | Ação                           |
+| ----------- | -------------------- | ------------------------------ |
+| A           | Etapa = "Ganha"      | Enviar e-mail de parabéns      |
+| B           | Etapa = "Perdida"    | Criar tarefa de acompanhamento |
+| C           | Etapa = "Negociação" | Notificar o gerente            |
+
+1. Crie ramificações a partir do seu gatilho ou ação
+2. Adicione um nó **Filtro** como a primeira etapa de cada ramificação
+3. Configure cada filtro com condições mutuamente exclusivas
+4. Adicione suas ações após cada filtro
+
+Apenas as ramificações em que a condição do filtro for atendida continuarão a ser executadas.
+
+## Mesclando Ramificações
+
+**As ramificações não se mesclam automaticamente.** Cada ramificação é executada de forma independente até terminar. Você tem total flexibilidade em como lidar com isso:
+
+* **Opção 1: Manter ramificações separadas**
+  Cada ramificação lida com suas próprias ações de acompanhamento de forma independente. Esta é a abordagem mais simples quando as ramificações não precisam convergir.
+
+* **Opção 2: Mesclar ramificações manualmente**
+  Ao criar seu fluxo de trabalho, você pode conectar manualmente várias ramificações à mesma ação subsequente. Basta arrastar setas do final de cada ramificação para um nó comum.
+
+<Note>
+Embora você possa usar um nó [Atraso](/l/pt/user-guide/workflows/capabilities/workflow-actions#delay) para pausar a execução, atualmente não é possível configurá-lo para esperar "até que outra ramificação termine".
+</Note>
+
+## Relacionados
+
+* [Como usar ramificações em Fluxos de Trabalho](/l/pt/user-guide/workflows/capabilities/use-branches-in-workflows) - Guia passo a passo
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions) - Ações disponíveis, incluindo Filtro

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-credits.mdx

@@ -0,0 +1,75 @@
+---
+title: Créditos de Fluxo de Trabalho
+description: Entenda o consumo e o gerenciamento de créditos de fluxo de trabalho.
+---
+
+Os créditos de fluxo de trabalho alimentam suas automações no Twenty. Entender como eles funcionam ajuda você a otimizar custos e gerenciar seu orçamento de automação de maneira eficaz.
+
+## Alocação de créditos
+
+Os créditos de fluxo de trabalho são alocados com base no seu ciclo de faturamento, não no seu nível de plano:
+
+| Ciclo de faturamento  | Créditos            |
+| --------------------- | ------------------- |
+| **Assinatura mensal** | 5 créditos por mês  |
+| **Assinatura anual**  | 50 créditos por ano |
+
+<Note>
+5 créditos mensais são generosos para automações padrão. A maioria das equipes não excederá esse limite com o uso típico de fluxos de trabalho. Créditos adicionais são necessários principalmente para ações de Code avançadas e fluxos de trabalho com tecnologia de IA.
+</Note>
+
+## Como Funciona o Consumo de Créditos
+
+Os créditos são consumidos quando os fluxos de trabalho são executados, não quando você os cria. Cada ação de fluxo de trabalho consome créditos com base em sua complexidade:
+
+### Consumo de Créditos por Tipo de Ação
+
+* **Operações internas básicas**: Consumo de créditos muito baixo
+  * Pesquisar Registros
+  * Criar Registro
+  * Atualizar Registro
+  * Excluir Registro
+  * Ações de formulário
+
+* **Operações complexas**: Maior consumo de créditos
+  * Ações de código (execução de JavaScript)
+  * Solicitações HTTP para serviços externos
+
+* **Recursos de IA**: Maior consumo de créditos
+  * As ações do Agente de IA consomem créditos com base no modelo de IA usado
+  * Prompts mais complexos e saídas mais longas consomem mais créditos
+
+* **Ações de Delay**: Consumo mínimo de créditos
+  * O nó Delay consome **1 crédito** quando é executado
+  * **Nenhum crédito é consumido** durante o período de espera
+  * Um atraso de 5 minutos custa o mesmo que um atraso de 5 dias
+
+### Dedução em Tempo Real
+
+Os créditos são deduzidos em tempo real à medida que os fluxos de trabalho são executados. Isso significa:
+
+* Fluxos de trabalho em rascunho não consomem créditos
+* Apenas fluxos de trabalho ativos e em execução usam sua alocação de crédito
+* Fluxos de trabalho com falha ainda consomem créditos para etapas concluídas
+
+## Gerenciamento de Créditos
+
+### Verificar Uso de Créditos
+
+1. Vá para **Configurações → Faturamento**
+2. Veja o seu consumo atual de créditos e o saldo restante
+3. Monitore padrões de uso para otimizar seus fluxos de trabalho
+
+### Compra de Créditos Adicionais
+
+Se você precisar de mais créditos além da alocação do seu plano:
+
+1. Vá para **Configurações → Faturamento**
+2. Clique na opção para comprar créditos adicionais. Pacotes de diferentes tamanhos estão disponíveis.
+3. Os créditos são adicionados ao seu saldo atual
+
+## Melhores Práticas
+
+* **Processamento em Lote**: Use operações em massa e ações de Iterador de forma eficiente para reduzir chamadas de ações individuais
+* **Otimização de Gatilhos Manuais**: Para gatilhos manuais, escolha a disponibilidade `Em Massa` para processar vários registros em uma única execução de fluxo de trabalho
+* Otimize as ações de código para eficiência

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-runs.mdx

@@ -0,0 +1,93 @@
+---
+title: Execuções de Workflow
+description: Monitore e gerencie as execuções de fluxos de trabalho.
+---
+
+## Sobre Execuções
+
+Uma **Execução** é um registro de uma execução de fluxo de trabalho. Sempre que um fluxo de trabalho é acionado — seja por um evento de registro, agendamento, ação manual ou webhook — uma nova execução é criada.
+
+## Visualizando Execuções
+
+### No Editor de Fluxo de Trabalho
+
+1. Abra o fluxo de trabalho que você deseja monitorar
+2. Clique no painel **Execuções** no lado direito
+3. Veja uma lista de execuções recentes com seus status
+
+### Na Visualização de Execuções de Fluxo de Trabalho
+
+1. Vá para **Execuções de Fluxo de Trabalho** na barra lateral
+2. Veja execuções em todos os fluxos de trabalho
+3. Filtre por status, fluxo de trabalho ou data
+
+## Status das Execuções
+
+| Estado         | Descrição                                                                                                  |
+| -------------- | ---------------------------------------------------------------------------------------------------------- |
+| **Executando** | O fluxo de trabalho está em execução no momento                                                            |
+| **Concluído**  | O fluxo de trabalho foi concluído com êxito                                                                |
+| **Falhou**     | O fluxo de trabalho encontrou um erro e foi interrompido                                                   |
+| **Aguardando** | O fluxo de trabalho está em pausa (por exemplo, aguardando uma ação de Atraso ou o envio de um Formulário) |
+
+## Detalhes da Execução
+
+Clique em qualquer execução para ver:
+
+* **Status**: Estado atual da execução
+* **Iniciado em**: Quando a execução começou
+* **Duração**: Quanto tempo a execução levou
+* **Dados do gatilho**: A entrada que iniciou o fluxo de trabalho
+* **Saídas das etapas**: Dados retornados por cada etapa
+* **Mensagens de erro**: Se a execução falhou, o que deu errado
+
+## Execução passo a passo
+
+Cada execução mostra o progresso ao longo do seu fluxo de trabalho:
+
+1. Veja quais etapas foram concluídas com êxito
+2. Identifique onde ocorreram falhas
+3. Veja os dados passados entre as etapas
+4. Depure problemas examinando as entradas e saídas das etapas
+
+## Tratamento de Erros
+
+Quando uma execução falha:
+
+1. Abra a execução com falha
+2. Encontre a etapa que causou a falha
+3. Verifique a mensagem de erro para obter detalhes
+
+Problemas comuns:
+
+* Campos obrigatórios ausentes
+* Formato de dados inválido
+* Erros de API externa
+* Problemas de permissão
+
+## Reexecutando fluxos de trabalho
+
+Se uma execução falhar, você pode:
+
+* Corrija o problema subjacente e aguarde o próximo gatilho
+* Para fluxos de trabalho manuais, acione novamente com os mesmos dados ou dados atualizados
+* Revise a lógica do fluxo de trabalho para evitar falhas futuras
+
+## Dicas de desempenho
+
+### Gerenciando o histórico de execuções
+
+* As execuções são mantidas para referência histórica
+* Execuções muito antigas podem ser arquivadas automaticamente
+* Exporte os dados da execução se precisar manter registros
+
+### Melhores práticas de monitoramento
+
+* Verifique as execuções regularmente após ativar novos fluxos de trabalho
+* Revise as execuções com falha para identificar padrões
+
+## Relacionados
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Solução de Problemas de Fluxo de Trabalho](/l/pt/user-guide/workflows/how-tos/need-more-help/workflow-troubleshooting)

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-triggers.mdx

@@ -0,0 +1,137 @@
+---
+title: Gatilhos de Fluxo de Trabalho
+description: Conheça os diferentes gatilhos que iniciam os seus fluxos de trabalho.
+---
+
+## Sobre os Gatilhos
+
+Os fluxos de trabalho sempre começam com um único gatilho que define quando a automação deve ser executada.
+
+<img src="/images/user-guide/workflows/workflow_triggers.png" style={{width:'100%'}} />
+
+<Tip>
+**Objetos avançados são suportados!** Além dos objetos padrão de CRM (Pessoas, Empresas, Oportunidades), você também pode acionar fluxos de trabalho e executar ações em:
+* Membros do Workspace
+* Eventos de Calendário
+* Mensagens (E-mails)
+* Tarefas, Notas e muitos outros objetos do sistema
+
+Isso possibilita automações poderosas, como notificar membros da equipe quando eventos de calendário são criados ou processar automaticamente e-mails recebidos.
+</Tip>
+
+## Registro é Criado
+
+Inicia o fluxo de trabalho quando um novo registro é criado em um objeto selecionado (Pessoas, Empresas, Oportunidades ou qualquer objeto personalizado).
+
+**Configuração**: Selecione o tipo de objeto para monitorar novos registros.
+
+<Note>
+* Este gatilho é ótimo para registros criados por CSV, caixa de correio e sincronização de calendário, ou API.
+* **Não é recomendado para registros criados manualmente**: com este gatilho, os fluxos de trabalho começam assim que o registro é criado. Uma vez que Vinte Interface oferece auto-salvamento em tempo real (não há modo de edição e depois uma validação para salvar registros), o fluxo de trabalho será acionado antes do usuário inserir todos os campos.
+  Para acionar este fluxo de trabalho em registros criados manualmente, recomenda-se usar o gatilho `Record is created or updated`.
+</Note>
+
+## Registro é Atualizado
+
+Inicia o fluxo de trabalho quando alterações são feitas em um registro existente.
+
+**Configuração**:
+
+* Selecione o tipo de objeto
+* Opcionalmente, especifique quais campos monitorar para alterações
+
+## Registro é Atualizado ou Criado
+
+Inicia o fluxo de trabalho quando um registro é criado ou atualizado em um objeto selecionado.
+
+**Por que isto é importante**: Este gatilho é particularmente útil porque registros criados por métodos diferentes se comportam de maneira diferente:
+
+* **Importações API/CSV**: Registros são criados com todos os campos preenchidos imediatamente
+* **Criação manual**: Registros são criados primeiro, depois os campos são adicionados em atualizações subsequentes
+
+**Configuração**:
+
+* Selecione o tipo de objeto para monitorar
+* Opcionalmente, especifique quais campos monitorar para alterações
+* O fluxo de trabalho será acionado tanto na criação inicial quanto em quaisquer atualizações subsequentes
+
+## Registro é Excluído
+
+Inicia o fluxo de trabalho quando um registro é removido de um objeto.
+
+**Configuração**: Selecione o tipo de objeto para monitorar exclusões.
+
+## Gatilho Manual
+
+Inicia o fluxo de trabalho quando acionado por uma ação do usuário. Este gatilho pode ser acessado pelo menu `Cmd+K` ou por um botão personalizado que será exibido na barra de navegação superior após selecionar um ou mais registros.
+
+<img src="/images/user-guide/workflows/add_to_newsletter_button.png" style={{width:'100%'}} />
+
+**Configuração de Disponibilidade**:
+Escolha como o fluxo de trabalho deve lidar com a seleção de registros:
+
+* **Global**: Nenhum registro é necessário para acionar este fluxo de trabalho. O fluxo de trabalho é acionado no menu de comando `Cmd+K` em qualquer lugar (de qualquer objeto) e não usa o(s) registro(s) como entrada.
+
+Para a disponibilidade de **Single** e **Bulk**, os registros selecionados serão passados para o seu fluxo de trabalho. Isto é configurado para um determinado objeto, e vários registros podem ser selecionados antes de acionar o fluxo de trabalho.
+
+* **Simples**: O fluxo de trabalho será executado do início ao fim tantas vezes quanto há registros selecionados.
+
+  <Note>
+    **Limite flexível: 100 execuções/minuto**. Além disso, os fluxos de trabalho permanecem com o status "Not Started" e são processados gradualmente — seja por uma tarefa em segundo plano ou quando outro fluxo de trabalho entra na fila. Isso significa que você pode selecionar mais de 100 registros com um gatilho único; a execução será apenas mais lenta.
+  </Note>
+
+* **Bulk**: O fluxo de trabalho será executado uma vez, fornecendo toda a lista de registros como entrada. Isso significa que o fluxo de trabalho precisa conter uma [ação de iterador](/l/pt/user-guide/workflows/capabilities/workflow-actions#iterator).
+
+<Note>
+Isto é mais avançado e é melhor para pessoas que desejam otimizar o número de execuções de fluxo de trabalho.
+</Note>
+
+<img src="/images/user-guide/workflows/manual_trigger.png" style={{width:'100%'}} />
+
+**Configuração Adicional**:
+
+* Selecione o objeto alvo (para disponibilidade Única e em Massa)
+* Escolha um ícone de comando para acionar o fluxo de trabalho
+* Configure o local da barra de navegação (Fixado ou Não Fixado)
+
+**Métodos de Acesso**:
+
+* `Cmd+K` menu para encontrar e iniciar fluxos de trabalho manuais
+* Botão personalizado na barra de navegação superior (se configurado)
+
+## Gatilho baseado em tempo: Em um cronograma
+
+Inicia o fluxo de trabalho em uma base recorrente que você define.
+
+**Configuração**:
+
+* Selecione a unidade de tempo (minutos, horas, dias)
+* Insira um valor ou utilize expressões cron personalizadas para agendamentos avançados
+
+<Note>
+**Fuso horário**: Fluxos de trabalho agendados são executados em **UTC**. Ao definir horários para agendamentos diários, converta seu horário local para UTC.
+</Note>
+
+## Gatilho Externo: Webhook
+
+Inicia o fluxo de trabalho quando uma solicitação GET ou POST é recebida de um serviço externo.
+
+<img src="/images/user-guide/workflows/webhook_trigger.png" style={{width:'100%'}} />
+
+**Configuração**:
+
+* O fluxo de trabalho fornece uma URL de webhook exclusiva — copie-a e adicione-a ao seu sistema externo como o endpoint a ser chamado.
+* Para requisições POST, defina a estrutura de corpo esperada para que o Twenty saiba quais dados esperar. Adicione aqui os campos que você receberá e que serão necessários abaixo no seu fluxo de trabalho.
+* Configure a autenticação (em breve).
+
+## Escolhendo o Gatilho Correto
+
+| Caso de uso                                   | Gatilho recomendado             |
+| --------------------------------------------- | ------------------------------- |
+| Novos leads precisam de processamento         | Registro é Criado               |
+| Alterações de dados precisam de sincronização | Registro é Atualizado           |
+| Importação/manipulação manual de dados        | Registro é Atualizado ou Criado |
+| Limpeza após exclusão                         | Registro é Excluído             |
+| Ação iniciada pelo usuário                    | Iniciar Manualmente             |
+| Relatórios recorrentes                        | Agendamento                     |
+| Integração externa                            | Webhook ou Em um cronograma     |

packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-versions.mdx

@@ -0,0 +1,84 @@
+---
+title: Versões de Workflow
+description: Gerenciar versões e rascunhos de workflow.
+---
+
+## Sobre versões
+
+Sempre que você ativa um workflow, uma nova versão é criada. Isso permite acompanhar as alterações ao longo do tempo e reverter para configurações anteriores, se necessário.
+
+## Status das versões
+
+| Estado         | Descrição                                         |
+| -------------- | ------------------------------------------------- |
+| **Rascunho**   | Sendo editado, ainda não publicado                |
+| **Ativo**      | Versão ao vivo respondendo a gatilhos             |
+| **Desativado** | Anteriormente ativo, mas interrompido manualmente |
+| **Arquivado**  | Versões passadas mantidas para histórico          |
+
+## Trabalhando com rascunhos
+
+Ao editar um workflow ativo, as alterações são salvas como um **rascunho**. A versão ativa continua em execução enquanto você trabalha nas atualizações.
+
+Quando terminar de editar, você pode:
+
+* **Ativar**: Publicar o rascunho como a nova versão ativa (a versão anterior é arquivada)
+* **Descartar**: Excluir o rascunho e manter a versão ativa atual
+
+## Histórico de Versões
+
+### Visualizando versões anteriores
+
+1. Abra o workflow
+2. Clique na aba **Versões**
+3. Veja todas as versões anteriores com carimbos de data e hora
+
+### Restaurando uma versão
+
+1. Encontre a versão que deseja restaurar
+2. Clique em **Usar como rascunho**
+3. A versão é copiada para um novo rascunho
+4. Faça as atualizações necessárias
+5. Ative quando estiver pronto
+
+## Melhores Práticas
+
+### Gerenciamento de versões
+
+* Ative somente quando estiver pronto para produção
+* Mantenha mudanças relevantes entre versões
+* Documente mudanças importantes em nomes ou descrições de workflows
+* Teste no modo de rascunho antes de ativar
+
+### Revertendo alterações
+
+* Se uma nova versão causar problemas, restaure a versão anterior
+* Use o histórico de versões para acompanhar o que mudou
+* Sempre teste versões restauradas antes de ativar
+
+## Workflows comuns
+
+### Edição rápida
+
+1. Faça pequenas alterações em um workflow ativo
+2. Teste no modo de rascunho
+3. Ative a nova versão
+
+### Revisão importante
+
+1. Use a versão anterior como ponto de partida
+2. Faça alterações significativas no rascunho
+3. Teste minuciosamente todos os cenários
+4. Ative quando estiver confiante
+
+### Reversão
+
+1. Identifique o problema na versão atual
+2. Encontre a última versão funcional no histórico
+3. Clique em **Usar como rascunho**
+4. Ative para restaurar o comportamento anterior
+
+## Relacionados
+
+* [Primeiros passos com Workflows](/l/pt/user-guide/workflows/overview)
+* [Execuções de Workflows](/l/pt/user-guide/workflows/capabilities/workflow-runs)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx

@@ -0,0 +1,82 @@
+---
+title: Tratar arrays em ações de Código
+description: Aprenda a tratar corretamente entradas de array em ações de Código em fluxos de trabalho.
+---
+
+Ao trabalhar com arrays em ações de Código, você pode encontrar dois desafios comuns:
+
+1. **Arrays passados como strings** — dados de sistemas externos ou de etapas anteriores chegam como uma string em vez de um array real
+2. **Não é possível selecionar itens individualmente** — você só consegue selecionar o array inteiro, não campos específicos dentro dele
+
+Ambos podem ser resolvidos com um nó de Código.
+
+## Analisar arrays a partir de strings
+
+Com frequência, arrays são passados entre etapas do fluxo de trabalho como strings ou JSON, em vez de arrays nativos. Isso acontece quando:
+
+* Recebendo dados de APIs externas via HTTP Request
+* Processando payloads de webhooks
+* Transmitindo dados entre etapas do fluxo de trabalho
+
+**Solução**: Adicione este padrão no início da sua ação de Código:
+
+```javascript
+export const main = async (params: {
+  users: any;
+}): Promise<object> => {
+  const { users } = params;
+
+  // Handle input that may come as a string or an array
+  const usersFormatted = typeof users === "string" ? JSON.parse(users) : users;
+
+  // Now you can safely work with usersFormatted as an array
+  return {
+    users: usersFormatted.map((user) => ({
+      ...user,
+      activityStatus: String(user.activityStatus).toUpperCase(),
+    })),
+  };
+};
+```
+
+A linha chave `typeof users === "string" ? JSON.parse(users) : users` verifica se a entrada é uma string, faz o parse se necessário ou a utiliza diretamente se já for um array.
+
+## Extraindo campos individuais de arrays
+
+Um webhook pode retornar um array como `answers: [...]`, mas, nas etapas seguintes do fluxo de trabalho, você só consegue selecionar o **array inteiro** — não itens individuais dentro dele.
+
+**Solução**: Adicione um nó de Código para extrair campos específicos e retorná-los como um objeto estruturado:
+
+```javascript
+export const main = async (params: {
+  answers: any;
+}): Promise<object> => {
+  const { answers } = params;
+
+  // Handle input that may come as a string or an array
+  const answersFormatted = typeof answers === "string"
+    ? JSON.parse(answers)
+    : answers;
+
+  // Extract specific fields from the array
+  const firstname = answersFormatted[0]?.text || "";
+  const name = answersFormatted[1]?.text || "";
+
+  return {
+    answer: {
+      firstname,
+      name
+    }
+  };
+};
+```
+
+O nó de Código retorna um objeto estruturado em vez de um array. Nas etapas subsequentes, agora você pode selecionar campos individuais como `answer.firstname` e `answer.name` no seletor de variáveis.
+
+<Tip>
+**Quer iterar sobre o array em vez de extrair campos?** Quando uma etapa Code ou Logic Function retorna um array de nível superior, você pode passá-lo diretamente para um [Iterator](/l/pt/user-guide/workflows/capabilities/use-iterator): selecione a opção **Whole list** da etapa como entrada do Iterator e, em seguida, faça referência a cada elemento com `{{iterator.currentItem}}` dentro do loop. Nesse caso, você não precisa reestruturar o array em um objeto.
+</Tip>
+
+<Tip>
+Clique no ícone quadrado no canto superior direito do editor de código para exibi-lo em tela cheia — útil, já que a largura padrão do editor é limitada.
+</Tip>

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/bring-product-data-in-twenty.mdx

@@ -0,0 +1,182 @@
+---
+title: Traga dados de produtos para o Twenty
+description: Sincronize, de forma agendada, os dados do catálogo de produtos do seu armazém de dados para o seu CRM.
+---
+
+Use este padrão para manter o Twenty sincronizado com os dados de produtos do seu armazém de dados (por exemplo, Snowflake, BigQuery, PostgreSQL).
+
+## Estrutura do Fluxo de Trabalho
+
+1. **Gatilho**: De forma agendada
+2. **Código**: Consultar seu armazém de dados
+3. **Código** (opcional): Formatar os dados como array
+4. **Iterador**: Percorrer cada produto
+5. **Inserir/atualizar registro**: Criar ou atualizar no Twenty
+
+<img src="/images/user-guide/workflows/create_users_workflow.png" style={{width:'100%'}} />
+
+## Etapa 1: Agendar o gatilho
+
+Defina o fluxo de trabalho para executar em uma frequência que atenda às suas necessidades de atualização dos dados:
+
+* A cada 5 minutos para sincronização quase em tempo real
+* A cada hora para dados menos críticos
+* Diariamente para atualizações em lote
+
+## Etapa 2: Consultar seu armazém de dados
+
+Adicione uma ação de **Código** para buscar dados recentes:
+
+```javascript
+export const main = async () => {
+  const intervalMinutes = 10; // Match your schedule frequency
+  const cutoffTime = new Date(Date.now() - intervalMinutes * 60 * 1000).toISOString();
+
+  // Replace with your actual data warehouse connection
+  const response = await fetch("https://your-warehouse-api.com/query", {
+    method: "POST",
+    headers: {
+      "Authorization": "Bearer YOUR_API_KEY",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: `
+        SELECT id, name, sku, price, stock_quantity, updated_at
+        FROM products
+        WHERE updated_at >= '${cutoffTime}'
+      `
+    })
+  });
+
+  const data = await response.json();
+  return { products: data.results };
+};
+```
+
+<Tip>
+Filtre por `updated_at >= last X minutes` para recuperar apenas registros alterados recentemente. Isso mantém a sincronização eficiente.
+</Tip>
+
+## Etapa 3: Formatar os dados (opcional)
+
+Se o seu armazém de dados retornar dados em um formato que precise de transformação, adicione outra ação de **Código**. Transformações comuns incluem conversões de tipo, renomeação de campos e limpeza de dados.
+
+### Exemplo: Dados de usuário com campos booleanos e de status
+
+```javascript
+export const main = async (params: {
+  users: any;
+}): Promise<object> => {
+  const { users } = params;
+  const usersFormatted = typeof users === "string" ? JSON.parse(users) : users;
+
+  // Convert string "true"/"false" to actual booleans
+  const toBool = (v: any) => v === true || v === "true";
+
+  return {
+    users: usersFormatted.map((user) => ({
+      ...user,
+      activityStatus: String(user.activityStatus).toUpperCase(),
+      isActiveLast30d: toBool(user.isActiveLast30d),
+      isActiveLast7d: toBool(user.isActiveLast7d),
+      isActiveLast24h: toBool(user.isActiveLast24h),
+      isTwenty: toBool(user.isTwenty),
+    })),
+  };
+};
+```
+
+### Exemplo: Dados de produto com conversões de tipo
+
+```javascript
+export const main = async (params: { products: any }) => {
+  const products = typeof params.products === "string"
+    ? JSON.parse(params.products)
+    : params.products;
+
+  return {
+    products: products.map(product => ({
+      externalId: product.id,
+      name: product.name,
+      sku: product.sku,
+      price: parseFloat(product.price),        // String → Number
+      stockQuantity: parseInt(product.stock_quantity),
+      isActive: product.status === "active"    // String → Boolean
+    }))
+  };
+};
+```
+
+### Exemplo: Formatação de data e moeda
+
+```javascript
+export const main = async (params: { deals: any }) => {
+  const deals = typeof params.deals === "string"
+    ? JSON.parse(params.deals)
+    : params.deals;
+
+  return {
+    deals: deals.map(deal => ({
+      ...deal,
+      // Convert Unix timestamp to ISO date
+      closedAt: deal.closed_timestamp
+        ? new Date(deal.closed_timestamp * 1000).toISOString()
+        : null,
+      // Ensure amount is a number (remove currency symbols)
+      amount: parseFloat(String(deal.amount).replace(/[^0-9.-]/g, "")),
+      // Normalize stage names
+      stage: deal.stage?.toLowerCase().replace(/_/g, " ")
+    }))
+  };
+};
+```
+
+### Transformações comuns
+
+| Formato de origem    | Formato de destino | Código                                   |
+| -------------------- | ------------------ | ---------------------------------------- |
+| `"true"` / `"false"` | `true` / `false`   | `v === true \|\| v === "true"`           |
+| `"123.45"`           | `123.45`           | `parseFloat(value)`                      |
+| `"active"`           | `"ACTIVE"`         | `value.toUpperCase()`                    |
+| `1704067200` (Unix)  | Data ISO           | `new Date(v * 1000).toISOString()`       |
+| `"$1,234.56"`        | `1234.56`          | `parseFloat(v.replace(/[^0-9.-]/g, ""))` |
+| `null` / `undefined` | `""`               | `value \|\| ""`                          |
+
+## Etapa 4: Iterar pelos produtos
+
+Adicione uma ação de **Iterador**:
+
+* Entrada: `{{code.products}}`
+
+Isso percorre cada produto no array.
+
+## Etapa 5: Inserir/atualizar cada registro
+
+Dentro do iterador, adicione uma ação de **Inserir/atualizar registro**:
+
+| Configuração            | Valor                                   |
+| ----------------------- | --------------------------------------- |
+| **Objeto**              | Seu objeto Produto personalizado        |
+| **Correspondência por** | ID externo ou SKU (identificador único) |
+| **Nome**                | `{{iterator.item.name}}`                |
+| **SKU**                 | `{{iterator.item.sku}}`                 |
+| **Preço**               | `{{iterator.item.price}}`               |
+
+<Tip>
+Use **inserir/atualizar** (atualizar ou criar) em vez de construir ramificações separadas para criação vs. atualização. É mais rápido de construir e mais fácil de depurar.
+</Tip>
+
+## Casos de uso de exemplo
+
+| Fonte                        | Data                                        |
+| ---------------------------- | ------------------------------------------- |
+| **Sistema ERP**              | Catálogo de produtos, preços, inventário    |
+| **Plataforma de e-commerce** | Pedidos, clientes, atualizações de produtos |
+| **Armazém de dados**         | Métricas agregadas, dados enriquecidos      |
+| **Sistema de inventário**    | Níveis de estoque, alertas de reposição     |
+
+## Relacionados
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Lidar com arrays em ações de código](/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/bring-typeform-submissions-in-twenty.mdx

@@ -0,0 +1,130 @@
+---
+title: Importar envios do Typeform para o Twenty
+description: Trate a carga útil de webhook do Typeform para criar leads a partir de envios de formulários.
+---
+
+Para a configuração padrão de webhook, consulte [Configurar um gatilho de Webhook](/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger). Este artigo aborda o tratamento específico necessário para a estrutura de carga útil personalizada do Typeform.
+
+### Etapa 1: Criar um fluxo de trabalho de Webhook
+
+1. Vá para **Configurações → Fluxos de trabalho**
+2. Clique em **+ Novo fluxo de trabalho**
+3. Selecione **Webhook** como o gatilho
+4. Copie a URL do webhook
+
+### Etapa 2: Configurar o Typeform
+
+1. No Typeform, abra seu formulário
+2. Vá para **Connect → Webhooks**
+3. Cole a URL do webhook do Twenty
+4. Salvar
+
+### Etapa 3: Entender a carga útil do Typeform
+
+O Typeform envia uma estrutura JSON aninhada. Aqui está um exemplo simplificado:
+
+```json
+{
+  "event_type": "form_response",
+  "form_response": {
+    "form_id": "abc123",
+    "submitted_at": "2025-01-15T10:30:00Z",
+    "answers": [
+      {
+        "text": "Jane",
+        "type": "text",
+        "field": { "id": "field1", "type": "short_text", "title": "First Name" }
+      },
+      {
+        "text": "Smith",
+        "type": "text",
+        "field": { "id": "field2", "type": "short_text", "title": "Last Name" }
+      },
+      {
+        "text": "Acme Corp",
+        "type": "text",
+        "field": { "id": "field3", "type": "short_text", "title": "Company" }
+      },
+      {
+        "email": "jane@acme.com",
+        "type": "email",
+        "field": { "id": "field4", "type": "email", "title": "Email" }
+      },
+      {
+        "type": "choice",
+        "field": { "id": "field5", "type": "dropdown", "title": "Team Size" },
+        "choice": { "label": "10-50" }
+      }
+    ]
+  }
+}
+```
+
+Pontos importantes a observar:
+
+* Os dados do formulário estão aninhados em `form_response`
+* **As respostas são retornadas como um array**, não como campos nomeados
+* Cada resposta inclui o tipo e o título do campo para referência
+
+### Etapa 4: Extrair campos do array de respostas
+
+Como `answers` é um array, você só pode selecionar o array inteiro nas etapas subsequentes — não campos individuais. Adicione uma ação de **Código** para extrair os campos necessários:
+
+```javascript
+export const main = async (params: {
+  answers: any;
+}): Promise<object> => {
+  const { answers } = params;
+
+  // Handle input that may come as a string or an array
+  const answersFormatted = typeof answers === "string"
+    ? JSON.parse(answers)
+    : answers;
+
+  // Extract fields by position or by finding the field type
+  const firstName = answersFormatted[0]?.text || "";
+  const lastName = answersFormatted[1]?.text || "";
+  const company = answersFormatted[2]?.text || "";
+  const email = answersFormatted.find(a => a.type === "email")?.email || "";
+  const teamSize = answersFormatted.find(a => a.type === "choice")?.choice?.label || "";
+
+  return {
+    contact: {
+      firstName,
+      lastName,
+      company,
+      email,
+      teamSize
+    }
+  };
+};
+```
+
+Nas etapas subsequentes, agora você pode selecionar campos individuais como `contact.firstName` e `contact.email` no seletor de variáveis.
+
+<Tip>
+Para mais detalhes sobre como lidar com arrays, consulte [Tratar arrays em ações de código](/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions).
+</Tip>
+
+### Etapa 5: Criar o registro
+
+Adicione a ação **Criar registro**:
+
+| Campo       | Valor                                                     |
+| ----------- | --------------------------------------------------------- |
+| **Objeto**  | Pessoas                                                   |
+| **Nome**    | `{{code.contact.firstName}}`                              |
+| **Apelido** | `{{code.contact.lastName}}`                               |
+| **Email**   | `{{code.contact.email}}`                                  |
+| **Empresa** | Pesquisar ou criar com base em `{{code.contact.company}}` |
+
+### Etapa 6: Testar e ativar
+
+1. Envie uma resposta de teste no Typeform
+2. Verifique a execução do fluxo de trabalho para verificar se os dados foram capturados
+3. Ative o fluxo de trabalho
+
+## Relacionados
+
+* [Configurar um gatilho de Webhook](/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger)
+* [Lidar com arrays em ações de código](/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty.mdx

@@ -0,0 +1,263 @@
+---
+title: Gerar um PDF a partir do Twenty
+description: Crie um fluxo de trabalho para gerar e anexar um PDF (como um orçamento) a um registo.
+---
+
+Gere automaticamente ou obtenha um PDF e anexe-o a um registo no Twenty. Isto é normalmente utilizado para criar orçamentos, faturas ou relatórios que estão associados a Empresas, Oportunidades ou outros objetos.
+
+## Visão Geral
+
+Este fluxo de trabalho utiliza um **Gatilho Manual** para que os utilizadores possam gerar um PDF a pedido para qualquer registo selecionado. Uma **Função lógica** trata de:
+
+1. Transferir o PDF a partir de um URL (de um serviço de geração de PDF)
+2. Carregar o ficheiro para o Twenty
+3. Criar um Anexo ligado ao registo
+
+## Pré-requisitos
+
+Antes de configurar o fluxo de trabalho:
+
+1. **Crie uma Chave de API**: Vá a **Definições → APIs** e crie uma nova chave de API. Você precisará deste token para a função lógica.
+2. **Configure um serviço de geração de PDF** (opcional): Se quiser gerar PDFs dinamicamente (por exemplo, orçamentos), utilize um serviço como o Carbone, o PDFMonkey ou o DocuSeal para criar o PDF e obter um URL de transferência.
+
+## Configuração passo a passo
+
+### Etapa 1: Configurar o gatilho
+
+1. Vá a **Fluxos de Trabalho** e crie um novo fluxo de trabalho
+2. Selecione **Gatilho Manual**
+3. Escolha o objeto ao qual pretende anexar PDFs (por exemplo, **Empresa** ou **Oportunidade**)
+
+<Tip>
+Com um disparador Manual usuários podem executar este fluxo de trabalho usando um botão que aparece no topo direito, depois que um registro é selecionado — isso executa o fluxo de trabalho para gerar e anexar um PDF.
+</Tip>
+
+### Passo 2: Adicionar uma Função lógica
+
+1. Adicionar uma ação **Código** (função lógica)
+2. Crie uma nova função com o código abaixo
+3. Configure os parâmetros de entrada
+
+#### Parâmetros de Entrada
+
+| Parâmetro   | Valor                   |
+| ----------- | ----------------------- |
+| `companyId` | `{{trigger.object.id}}` |
+
+<Note>
+Se estiver a anexar a um objeto diferente (Pessoa, Oportunidade, etc.), renomeie o parâmetro em conformidade (por exemplo, `personId`, `opportunityId`) e atualize a função lógica.
+</Note>
+
+#### Código da Função lógica
+
+```typescript
+export const main = async (
+  params: { companyId: string },
+) => {
+  const { companyId } = params;
+  // Replace with your Twenty GraphQL endpoints (/metadata for metadata and files or /graphql for your records)
+  // Cloud: https://api.twenty.com/graphql
+  // Self-hosted: https://your-domain.com/graphql
+
+  const metadataGraphqlEndpoint = 'https://api.twenty.com/metadata';
+  const dataGraphqlEndpoint = 'https://api.twenty.com/graphql';
+
+  // Replace with your API key from Settings → APIs
+  const authToken = 'YOUR_API_KEY';
+
+  // Replace with your PDF URL
+  // This could be from a PDF generation service or a static URL
+  const pdfUrl = 'https://your-pdf-service.com/generated-quote.pdf';
+  const filename = 'quote.pdf';
+
+  // Step 1: Download the PDF file
+  const pdfResponse = await fetch(pdfUrl);
+
+  if (!pdfResponse.ok) {
+    throw new Error(`Failed to download PDF: ${pdfResponse.status}`);
+  }
+
+  const pdfBlob = await pdfResponse.blob();
+  const pdfFile = new File([pdfBlob], filename, { type: 'application/pdf' });
+
+  const fieldMetadataIdQuery = `
+    query FindUploadFileFieldMetadataId {
+      objects {
+        edges {
+          node {
+            nameSingular
+            fieldsList {
+              id
+              name
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  // Step 2: Find a fieldMetadataId of "Attachment file" field in Attachments object with GraphQL API
+  const response = await fetch(metadataGraphqlEndpoint, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      },
+      body: {
+        query: fieldMetadataIdQuery,
+      }
+    });
+  const result = await response.json();
+  const uploadFileFieldMetadataId = result.data.objects.edges.find(object => object.node.nameSingular === 'attachment').node.fieldsList.find(field => field.name === 'file').id;
+
+  // Step 3: Upload the file via GraphQL multipart upload
+  const uploadMutation = `
+    mutation UploadFilesFieldFile($file: Upload!, $fieldMetadataId: String!) {
+      uploadFilesFieldFile(file: $file, fieldMetadataId: $fieldMetadataId) {
+        id
+      }
+    }
+  `;
+
+  const uploadForm = new FormData();
+  uploadForm.append('operations', JSON.stringify({
+    query: uploadMutation,
+    variables: { file: null, fieldMetadataId: uploadFileFieldMetadataId },
+  }));
+  uploadForm.append('map', JSON.stringify({ '0': ['variables.file'] }));
+  uploadForm.append('0', pdfFile);
+
+  const uploadResponse = await fetch(metadataGraphqlEndpoint, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${authToken}` },
+    body: uploadForm,
+  });
+
+  const uploadResult = await uploadResponse.json();
+
+  if (uploadResult.errors?.length) {
+    throw new Error(`Upload failed: ${uploadResult.errors[0].message}`);
+  }
+
+  const fileId = uploadResult.data?.uploadFilesFieldFile?.id;
+
+  if (!fileId) {
+    throw new Error('No file id returned from upload');
+  }
+
+  // Step 4: Create the attachment linked to the company
+  const attachmentMutation = `
+    mutation CreateOneAttachment($data: AttachmentCreateInput!) {
+      createAttachment(data: $data) {
+        id
+        name
+      }
+    }
+  `;
+
+  const attachmentResponse = await fetch(dataGraphqlEndpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      query: attachmentMutation,
+      variables: {
+        data: {
+          name: filename,
+          targetCompanyId: companyId,
+          file: [
+            {
+              fileId: fileId,
+              label: filename
+            }
+          ]
+        },
+      },
+    }),
+  });
+
+  const attachmentResult = await attachmentResponse.json();
+
+  if (attachmentResult.errors?.length) {
+    throw new Error(`Attachment creation failed: ${attachmentResult.errors[0].message}`);
+  }
+
+  return attachmentResult.data?.createAttachment;
+};
+```
+
+### Passo 3: Personalizar para o seu caso de utilização
+
+#### Para anexar a um objeto diferente
+
+Substitua `targetCompanyId` pelo campo apropriado:
+
+| Objeto               | Nome do Campo              |
+| -------------------- | -------------------------- |
+| Empresa              | `targetCompanyId`          |
+| Pessoa               | `targetPersonId`           |
+| Oportunidade         | `targetOpportunityId`      |
+| Objeto personalizado | `targetYourCustomObjectId` |
+
+Atualize tanto o parâmetro da função como o objeto `variables.data` na mutação de anexo.
+
+#### Para utilizar um URL de PDF dinâmico
+
+Se utilizar um serviço de geração de PDF, pode:
+
+1. Primeiro, faça uma ação de Pedido HTTP para gerar o PDF
+2. Passe o URL do PDF devolvido para a função lógica como parâmetro
+
+```typescript
+export const main = async (
+  params: { companyId: string; pdfUrl: string; filename: string },
+) => {
+  const { companyId, pdfUrl, filename } = params;
+  // ... rest of the function
+};
+```
+
+### Etapa 4: Testar e ativar
+
+1. Guarde o fluxo de trabalho
+2. Aceda a um registo de Empresa
+3. Clique no menu **⋮** e selecione o seu fluxo de trabalho
+4. Verifique a secção **Anexos** no registo para confirmar que o PDF foi anexado
+5. Ative o fluxo de trabalho
+
+## Combinar com Serviços de Geração de PDF
+
+Para criar orçamentos ou faturas dinâmicos:
+
+### Exemplo: Gerar Orçamento → Anexar PDF
+
+| Etapa | Ação                     | Finalidade                                             |
+| ----- | ------------------------ | ------------------------------------------------------ |
+| 1     | Gatilho Manual (Empresa) | O utilizador inicia num registo                        |
+| 2     | Pesquisar Registo        | Obter detalhes da Oportunidade ou dos itens de linha   |
+| 3     | Requisição HTTP          | Chamar a API de geração de PDF com os dados do registo |
+| 4     | Função lógica            | Transferir e anexar o PDF gerado                       |
+
+### Serviços Populares de Geração de PDF
+
+* **Carbone** - Geração de documentos baseada em modelos
+* **PDFMonkey** - Criação dinâmica de PDF a partir de modelos
+* **DocuSeal** - Plataforma de automatização de documentos
+* **Documint** - Geração de documentos orientada a API
+
+Cada serviço fornece uma API que retorna uma URL em PDF, que você pode passar para a função lógica.
+
+## Resolução de Problemas
+
+| Problema                    | Solução                                                                      |
+| --------------------------- | ---------------------------------------------------------------------------- |
+| "Falha ao transferir PDF"   | Verifique se o URL do PDF é acessível e devolve um PDF válido                |
+| "Falha ao carregar"         | Verifique se a sua chave de API é válida e tem permissões de escrita         |
+| "Falha na criação do anexo" | Garanta que o nome do campo de ID do objeto corresponde ao objeto de destino |
+
+## Relacionados
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Funções lógicas](/l/pt/user-guide/workflows/capabilities/workflow-actions#code)
+* [Gerar um Orçamento ou Fatura a partir do Twenty](/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/generate-quote-or-invoice-from-twenty)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/generate-quote-or-invoice-from-twenty.mdx

@@ -0,0 +1,144 @@
+---
+title: Gerar um orçamento ou fatura no Twenty
+description: Crie faturas automaticamente em ferramentas externas quando os negócios forem fechados.
+---
+
+Envie automaticamente os dados do negócio para o seu sistema de faturação (Stripe, QuickBooks, Xero, etc.) quando uma oportunidade é ganha.
+
+## Estrutura do Fluxo de Trabalho
+
+1. **Gatilho**: Registo é atualizado (Oportunidade)
+2. **Filtro**: Etapa = Closed Won
+3. **Pesquisar Registo**: Obter detalhes da empresa
+4. **Código** (opcional): Formatar o payload
+5. **Pedido HTTP**: Enviar para o sistema de faturação
+
+## Etapa 1: Configurar o Gatilho
+
+1. Crie um novo fluxo de trabalho
+2. Selecione o gatilho **Registo é atualizado**
+3. Escolha **Oportunidade** como o objeto
+
+## Etapa 2: Filtrar por Closed Won
+
+Adicione uma ação de **Filtro** para só continuar quando o negócio for ganho:
+
+| Configuração | Valor                                 |
+| ------------ | ------------------------------------- |
+| **Campo**    | Etapa                                 |
+| **Condição** | Igual a                               |
+| **Valor**    | `CLOSED_WON` (ou o nome da sua etapa) |
+
+<Tip>
+O gatilho é acionado em qualquer atualização de Oportunidade. O Filtro garante que o fluxo de trabalho só continue quando a etapa mudar para Closed Won.
+</Tip>
+
+## Etapa 3: Obter detalhes da empresa
+
+O registo de Oportunidade pode não incluir todos os campos da Empresa de que precisa para a fatura. Adicione uma ação de **Pesquisar Registo**:
+
+| Configuração            | Valor                                     |
+| ----------------------- | ----------------------------------------- |
+| **Objeto**              | Empresa                                   |
+| **Correspondência por** | ID igual a `{{trigger.object.companyId}}` |
+
+Isto obtém o registo completo da Empresa com morada de faturação, NIF, etc.
+
+## Etapa 4: Formatar o Payload (Opcional)
+
+Se o seu sistema de faturação esperar um formato específico, adicione uma ação de **Código**:
+
+```javascript
+export const main = async (params: {
+  opportunity: any;
+  company: any;
+}): Promise<object> => {
+  const { opportunity, company } = params;
+
+  return {
+    invoice: {
+      // Customer info from Company
+      customer_name: company.name,
+      customer_email: company.email || "",
+      billing_address: {
+        line1: company.address?.street || "",
+        city: company.address?.city || "",
+        postal_code: company.address?.postalCode || "",
+        country: company.address?.country || ""
+      },
+      tax_id: company.taxId || null,
+
+      // Invoice details from Opportunity
+      amount: opportunity.amount,
+      currency: opportunity.currency || "USD",
+      description: `Invoice for ${opportunity.name}`,
+      due_days: 30,
+
+      // Reference back to Twenty
+      metadata: {
+        opportunity_id: opportunity.id,
+        company_id: company.id
+      }
+    }
+  };
+};
+```
+
+## Etapa 5: Enviar para o Sistema de Faturação
+
+Adicione uma ação de **Pedido HTTP**:
+
+| Configuração   | Valor                                                          |
+| -------------- | -------------------------------------------------------------- |
+| **Método**     | POST                                                           |
+| **URL**        | O endpoint da API do seu sistema de faturação                  |
+| **Cabeçalhos** | `Authorization: Bearer YOUR_API_KEY`                           |
+| **Corpo**      | `{{code.invoice}}` ou faça o mapeamento dos campos diretamente |
+
+### Exemplo: Fatura Stripe
+
+```
+POST https://api.stripe.com/v1/invoices
+Headers:
+  Authorization: Bearer sk_live_xxx
+  Content-Type: application/x-www-form-urlencoded
+
+Body:
+  customer: {{company.stripeCustomerId}}
+  collection_method: send_invoice
+  days_until_due: 30
+```
+
+### Exemplo: Fatura QuickBooks
+
+```
+POST https://quickbooks.api.intuit.com/v3/company/{realmId}/invoice
+Headers:
+  Authorization: Bearer YOUR_ACCESS_TOKEN
+  Content-Type: application/json
+
+Body: {{code.invoice}}
+```
+
+## Resumo Completo do Fluxo de Trabalho
+
+| Etapa | Ação                        | Finalidade                                         |
+| ----- | --------------------------- | -------------------------------------------------- |
+| 1     | Gatilho: Registo atualizado | Dispara quando qualquer Oportunidade é alterada    |
+| 2     | Filtro                      | Só prossiga se Etapa = Closed Won                  |
+| 3     | Pesquisar Registo           | Obter detalhes completos da Empresa para faturação |
+| 4     | Código                      | Formatar dados para a API de faturação             |
+| 5     | Requisição HTTP             | Criar fatura no sistema externo                    |
+
+## Dicas
+
+* **Armazene IDs externos**: Guarde o ID da fatura retornado pela API na Oportunidade usando uma ação de **Atualizar Registo**
+* **Tratamento de erros**: Adicione uma ramificação para enviar uma notificação se o pedido HTTP falhar
+* **Teste primeiro**: Use o modo sandbox/de teste do seu sistema de faturação antes de ir para produção
+
+## Relacionados
+
+* [Gerar um PDF a partir do Twenty](/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/generate-pdf-from-twenty) — anexar PDFs gerados aos registros
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Automações de Closed Won](/l/pt/user-guide/workflows/how-tos/crm-automations/closed-won-automations)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/connect-to-other-tools/set-up-a-webhook-trigger.mdx

@@ -0,0 +1,170 @@
+---
+title: Configurar um gatilho de Webhook
+description: Receba dados de serviços externos para acionar fluxos de trabalho.
+---
+
+Gatilhos de Webhook permitem que serviços externos iniciem seus fluxos de trabalho enviando dados para uma URL exclusiva. Use-os para conectar formulários, aplicativos de terceiros e integrações personalizadas.
+
+## Quando usar Webhooks
+
+| Caso de uso                    | Exemplo                                         |
+| ------------------------------ | ----------------------------------------------- |
+| **Formulários da web**         | Envios de formulários de contato geram leads    |
+| **Aplicativos de terceiros**   | Pagamento no Stripe → criar registro de cliente |
+| **Integrações personalizadas** | Seu aplicativo → automação no Twenty            |
+| **Ferramentas no-code**        | Conexões com Zapier, Make, n8n                  |
+
+## Configuração passo a passo
+
+### Etapa 1: Criar o fluxo de trabalho
+
+1. Vá para **Configurações → Fluxos de trabalho**
+2. Clique em **+ Novo fluxo de trabalho**
+3. Dê um nome (por exemplo, "Envio de formulário do site")
+
+### Etapa 2: Configurar o gatilho de Webhook
+
+1. Clique no bloco de gatilho
+2. Selecione **Webhook**
+3. Você receberá uma URL de webhook exclusiva, como:
+   ```
+   https://api.twenty.com/webhooks/workflow/abc123...
+   ```
+4. Copie esta URL—você vai precisar dela no seu serviço externo
+
+### Etapa 3: Definir a estrutura de dados esperada
+
+Para solicitações **POST**, defina a estrutura esperada do corpo:
+
+1. Clique em **Definir corpo esperado**
+2. Insira um JSON de exemplo que corresponda ao que o seu serviço enviará:
+
+```json
+{
+  "firstName": "John",
+  "lastName": "Doe",
+  "email": "john@example.com",
+  "company": "Acme Inc",
+  "message": "Interested in your product"
+}
+```
+
+3. Clique em **Salvar**—isso cria variáveis que você pode usar nas etapas subsequentes
+
+### Etapa 4: Adicionar ações
+
+Agora adicione ações que usem os dados do webhook:
+
+**Exemplo: Criar um registro de Pessoa**
+
+1. Adicione a ação **Criar registro**
+2. Selecione o objeto **Pessoas**
+3. Mapeie os campos:
+
+| Campo     | Valor                                                     |
+| --------- | --------------------------------------------------------- |
+| Nome      | `{{trigger.body.firstName}}`                              |
+| Sobrenome | `{{trigger.body.lastName}}`                               |
+| E-mail    | `{{trigger.body.email}}`                                  |
+| Empresa   | Pesquisar ou criar com base em `{{trigger.body.company}}` |
+
+### Etapa 5: Testar o Webhook
+
+Antes de ativar, teste o seu webhook:
+
+**Usando cURL**:
+
+```bash
+curl -X POST https://api.twenty.com/webhooks/workflow/abc123... \
+  -H "Content-Type: application/json" \
+  -d '{"firstName":"Test","lastName":"User","email":"test@example.com"}'
+```
+
+**Usando o Postman ou similar**:
+
+1. Crie uma solicitação POST para a sua URL de webhook
+2. Defina o cabeçalho Content-Type como `application/json`
+3. Adicione o corpo JSON de teste
+4. Envie e verifique as execuções do fluxo de trabalho
+
+### Etapa 6: Ativar
+
+Depois de testar, clique em **Ativar** para ativar o fluxo de trabalho.
+
+## Como lidar com diferentes estruturas de dados
+
+### Dados aninhados
+
+Se o seu webhook enviar dados aninhados:
+
+```json
+{
+  "contact": {
+    "name": "John Doe",
+    "email": "john@example.com"
+  },
+  "source": "website"
+}
+```
+
+Referencie com: `{{trigger.body.contact.email}}`
+
+### Arrays
+
+Se os dados incluírem arrays:
+
+```json
+{
+  "items": [
+    {"name": "Product A", "qty": 2},
+    {"name": "Product B", "qty": 1}
+  ]
+}
+```
+
+Como você lida com arrays depende do seu caso de uso:
+
+**Número desconhecido de itens → Use Iterator**
+
+Se você precisar processar cada item no array (por exemplo, criar um registro para cada), adicione uma ação **Code** para analisar o array e, em seguida, use **Iterator**:
+
+```javascript
+export const main = async (params: { items: any }) => {
+  const items = typeof params.items === "string"
+    ? JSON.parse(params.items)
+    : params.items;
+  return { items };
+};
+```
+
+Em seguida, use Iterator para percorrer: `{{code.items}}`
+
+**Campos conhecidos/específicos → Extraia para campos nomeados**
+
+Se o array contiver campos específicos aos quais você deseja acessar individualmente (por exemplo, respostas de formulário em que a posição 0 é sempre "nome", a posição 1 é sempre "sobrenome"), adicione uma ação **Code** para extraí-los:
+
+```javascript
+export const main = async (params: { items: any }) => {
+  const items = typeof params.items === "string"
+    ? JSON.parse(params.items)
+    : params.items;
+
+  return {
+    product: {
+      name: items[0]?.name || "",
+      qty: items[0]?.qty || 0
+    }
+  };
+};
+```
+
+Agora você pode selecionar `product.name` e `product.qty` individualmente nas etapas subsequentes.
+
+<Tip>
+Para mais detalhes sobre como lidar com arrays, consulte [Tratar arrays em ações de código](/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions).
+</Tip>
+
+## Relacionados
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/auto-reply-to-inbound-emails.mdx

@@ -0,0 +1,121 @@
+---
+title: Resposta automática a e-mails de entrada
+description: Crie um fluxo de trabalho que use IA para fazer a triagem dos e-mails de entrada e enviar respostas encadeadas automaticamente.
+---
+
+Responda a e-mails de entrada em segundos — não em horas. Este fluxo de trabalho usa um Agente IA para filtrar ruído (boletins informativos, spam, respostas automáticas) e rascunhar uma resposta personalizada para mensagens reais. Então, AI o envia como uma resposta em tópico dentro da conversa original.
+
+## Como funciona o encadeamento de e-mails
+
+Cada e-mail contém um cabeçalho oculto `Message-ID` — uma impressão digital única atribuída pelo servidor de e-mail do remetente. Quando você responde a um e-mail, seu cliente de e-mail define um cabeçalho `In-Reply-To` que faz referência a essa impressão digital. É assim que o Gmail, o Outlook e todos os outros clientes agrupam as mensagens em conversas.
+
+No Twenty, essa impressão digital é armazenada como `headerMessageId` no objeto Message. Seu fluxo de trabalho obtém isso e o passa para o campo In-Reply-To da ação Enviar e-mail.
+
+## Criando o fluxo de trabalho
+
+### Etapa 1: Criar um novo fluxo de trabalho
+
+Vá para **Configurações -> Fluxos de trabalho** e clique em **+ Novo fluxo de trabalho**.
+
+### Etapa 2: Acionar com mensagens recebidas
+
+Escolha **When a Record is Created** e selecione **Messages**.
+
+Sempre que um e-mail chega ao Twenty, isto é acionado.
+
+<img src="/images/user-guide/workflows/auto-reply/workflow-overview.png" style={{width:'100%'}} />
+
+### Etapa 3: Procurar quem enviou
+
+Adicione uma ação **Pesquisar Registros**.
+
+O endereço do remetente não está na própria mensagem — está no registro relacionado Message Participant.
+
+| Campo      | Valor                          |
+| ---------- | ------------------------------ |
+| **Objeto** | Participantes da Mensagem      |
+| **Filtro** | Message **é** `{{trigger.id}}` |
+| **Filtro** | Função **é** From              |
+| **Limite** | 1                              |
+
+Isso fornece o e-mail do remetente em `handle` e o nome dele em `displayName`.
+
+<img src="/images/user-guide/workflows/auto-reply/find-sender.png" style={{width:'100%'}} />
+
+### Passo 4: Triage e rascunhar uma resposta com IA
+
+Adicione uma ação **Agente de IA**. Esta única etapa faz duas coisas: decide se o e-mail merece uma resposta e, se sim, redige uma.
+
+Use um prompt como:
+
+```
+You are an email triage assistant for a sales team. Read the following
+inbound email and decide if it deserves a reply.
+
+Subject: {{trigger.subject}}
+Body: {{trigger.text}}
+From: {{Find Sender.first.displayName}} ({{Find Sender.first.handle}})
+
+If this email is spam, a newsletter, an automated notification, or
+otherwise does not need a human reply, respond with exactly: SKIP
+
+Otherwise, write a short, professional reply (3-4 sentences max) that:
+- Acknowledges their specific message
+- Lets them know someone from the team will follow up shortly
+- Is warm but not overly casual
+
+Respond with only the reply text, no subject line or greeting prefix.
+```
+
+O Agente de IA produz sua resposta em um campo `response` ao qual as próximas etapas podem se referir.
+
+<img src="/images/user-guide/workflows/auto-reply/ai-triage.png" style={{width:'100%'}} />
+
+### Etapa 5: Ramificar com base na decisão da IA
+
+Adicione uma ação **If/Else** para verificar se a IA decidiu responder ou pular.
+
+| Campo              | Valor                                              |
+| ------------------ | -------------------------------------------------- |
+| **Condição**       | A `response` do Agente de IA **não contém** `SKIP` |
+| **Se verdadeiro**  | Continuar para Enviar e-mail                       |
+| **Caso contrário** | Não fazer nada (o fluxo de trabalho termina)       |
+
+Spam, boletins informativos e mensagens geradas automaticamente são descartados. Todo o restante segue para a próxima etapa.
+
+<img src="/images/user-guide/workflows/auto-reply/should-reply.png" style={{width:'100%'}} />
+
+### Etapa 6: Enviar uma resposta encadeada
+
+Adicione uma ação **Enviar e-mail** no ramo "se verdadeiro". Clique em **Opções avançadas** e depois em **Adicionar In-Reply-To**.
+
+| Campo           | Valor                                  |
+| --------------- | -------------------------------------- |
+| **Para**        | `{{Find Sender.first.handle}}`         |
+| **Assunto**     | `Re: {{trigger.subject}}`              |
+| **Corpo**       | `{{AI Triage & Draft Reply.response}}` |
+| **In-Reply-To** | `{{trigger.headerMessageId}}`          |
+
+O campo In-Reply-To é o que faz disso uma resposta em vez de uma nova conversa. O destinatário a vê encadeada sob o e-mail original no Gmail, Outlook ou qualquer outro cliente.
+
+<img src="/images/user-guide/workflows/auto-reply/send-email.png" style={{width:'100%'}} />
+
+<Tip>
+**In-Reply-To** espera um `message.headerMessageId` do acionador — é a impressão digital única do e-mail, não um endereço do destinatário. Se você deixá-lo vazio, o e-mail ainda será enviado, apenas como uma mensagem independente.
+</Tip>
+
+<Warning>
+O Gmail usa a linha de assunto para agrupar mensagens em conversas. O assunto **deve** começar com `Re:` (incluindo os dois-pontos e o espaço) para que o Gmail exiba a resposta dentro da conversa original. Sem isso, a resposta aparecerá como uma conversa separada — mesmo que o cabeçalho In-Reply-To esteja definido corretamente.
+</Warning>
+
+### Etapa 7: Testar e ativar
+
+Clique em **Test** e, em seguida, verifique seu cliente de e-mail. A resposta deve aparecer aninhada sob a mensagem original.
+
+Ative quando estiver satisfeito com isso.
+
+## Ideias para desenvolver
+
+* **Responder apenas a VIPs** — adicione um ramo que verifique o domínio do remetente ou se ele existe como um Contato no Twenty
+* **Roteie por intenção** — use prompts separados do Agente de IA para lidar com consultas de vendas de forma diferente de solicitações de suporte
+* **Enriquecer antes de responder** — adicione uma etapa Pesquisar Registros para trazer a empresa do remetente ou o histórico de negócios para o prompt de IA, obtendo respostas mais personalizadas

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/closed-won-automations.mdx

@@ -0,0 +1,179 @@
+---
+title: Automatizações para Closed Won
+description: Automatize as atividades pós-ganho quando as oportunidades forem encerradas.
+---
+
+Quando um negócio é encerrado, várias coisas precisam acontecer: atualizar o status da empresa, notificar os membros da equipe, criar tarefas de onboarding. Automatize tudo isso com um único fluxo de trabalho.
+
+## O Problema
+
+Quando uma oportunidade passa para "Closed Won":
+
+* O tipo de empresa precisa mudar de "Prospect" para "Customer"
+* Tarefas de onboarding precisam ser criadas
+* A equipe de Customer Success precisa ser notificada
+* O representante de vendas precisa de confirmação
+
+Fazer isso manualmente consome tempo e é suscetível a erros.
+
+## A Solução
+
+Crie um fluxo de trabalho que trate automaticamente todas as atividades pós-ganho.
+
+## Configuração Completa do Fluxo de Trabalho
+
+### Etapa 1: Criar o fluxo de trabalho
+
+1. Vá para **Configurações → Fluxos de trabalho**
+2. Clique em **+ Novo fluxo de trabalho**
+3. Nomeie como "Deal Won - Post-Win Automation"
+
+### Etapa 2: Configurar o gatilho
+
+1. Selecione **Record is Updated**
+2. Escolha **Oportunidades**
+3. Em "Campos para monitorar", selecione **Estágio**
+
+### Etapa 3: Adicionar filtro de estágio
+
+1. Adicione a ação **Filtro**
+2. Condição: `{{trigger.object.stage}}` é igual a "Closed Won"
+
+### Etapa 4: Atualizar o tipo de empresa
+
+1. Adicione a ação **Atualizar registro**
+2. Configurar:
+
+| Campo                        | Valor                           |
+| ---------------------------- | ------------------------------- |
+| **Objeto**                   | Empresas                        |
+| **Registro**                 | `{{trigger.object.company.id}}` |
+| **Tipo**                     | Cliente                         |
+| **Data do primeiro negócio** | `{{trigger.object.closedAt}}`   |
+| **Proprietário da Conta**    | `{{trigger.object.owner.id}}`   |
+
+### Etapa 5: Criar tarefa de onboarding
+
+1. Adicione a ação **Criar registro**
+2. Configurar:
+
+| Campo                        | Valor                                                                                                          |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| **Objeto**                   | Tarefas                                                                                                        |
+| **Título**                   | `Onboarding: {{trigger.object.name}}`                                                                          |
+| **Responsável**              | Membro da equipe de Customer Success                                                                           |
+| **Data de vencimento**       | Daqui a 3 dias                                                                                                 |
+| **Prioridade**               | Alta                                                                                                           |
+| **Empresa relacionada**      | `{{trigger.object.company.id}}`                                                                                |
+| **Oportunidade relacionada** | `{{trigger.object.id}}`                                                                                        |
+| **Descrição**                | `Onboarding de novo cliente para {{trigger.object.company.name}}. Valor do negócio: {{trigger.object.amount}}` |
+
+### Etapa 6: Notificar Customer Success
+
+1. Adicione a ação **Enviar e-mail**
+2. Configurar:
+
+| Campo       | Valor                                              |
+| ----------- | -------------------------------------------------- |
+| **Para**    | customer-success@yourcompany.com                   |
+| **Assunto** | `🎉 New Customer: {{trigger.object.company.name}}` |
+| **Corpo**   | Veja o exemplo abaixo                              |
+
+**Exemplo de corpo do e-mail**:
+
+```
+Hi CS Team,
+
+We have a new customer!
+
+Company: {{trigger.object.company.name}}
+Deal: {{trigger.object.name}}
+Value: {{trigger.object.amount}}
+Sales Rep: {{trigger.object.owner.name}}
+Close Date: {{trigger.object.closedAt}}
+
+An onboarding task has been created automatically.
+
+Let's give them a great start!
+```
+
+### Etapa 7: Confirmar para o representante de vendas
+
+1. Adicione outra ação **Enviar e-mail**
+2. Configurar:
+
+| Campo       | Valor                                                                                                          |
+| ----------- | -------------------------------------------------------------------------------------------------------------- |
+| **Para**    | `{{trigger.object.owner.email}}`                                                                               |
+| **Assunto** | `✅ Deal Closed: {{trigger.object.name}}`                                                                       |
+| **Corpo**   | Parabéns! Seu negócio foi processado. A equipe de Customer Success foi notificada e o onboarding foi iniciado. |
+
+### Etapa 8: Testar e ativar
+
+1. Teste movendo uma oportunidade de teste para "Closed Won"
+2. Verificar:
+   * Tipo de empresa alterado para "Customer"
+   * Tarefa de onboarding criada
+   * A equipe de CS recebeu o e-mail
+   * O representante de vendas recebeu a confirmação
+3. Ative quando estiver pronto
+
+## Tratamento de Closed Lost
+
+Crie um fluxo de trabalho semelhante para negócios perdidos:
+
+### Disparador
+
+* Registro é atualizado (Oportunidades, Estágio = "Closed Lost")
+
+### Ações
+
+1. **Criar registro**: Tarefa para "Análise de negócio perdido"
+2. **Atualizar registro**: Adicionar o motivo da perda ao registro da empresa
+3. **Enviar e-mail**: Notificar o gerente sobre o negócio perdido
+
+## Avançado: Onboarding em várias etapas
+
+Para um onboarding complexo, crie várias tarefas:
+
+```javascript
+export const main = async (params) => {
+  const tasks = [
+    { title: "Welcome call", daysFromNow: 1, assignee: "CS" },
+    { title: "Send onboarding materials", daysFromNow: 2, assignee: "CS" },
+    { title: "Technical setup", daysFromNow: 5, assignee: "Support" },
+    { title: "30-day check-in", daysFromNow: 30, assignee: "CS" }
+  ];
+
+  return { tasks };
+};
+```
+
+Use **Iterator** para criar cada tarefa a partir do array.
+
+## Ideias de personalização
+
+### Mantenha suas outras ferramentas atualizadas
+
+* Crie o cliente no sistema de faturamento com uma **Requisição HTTP**
+
+### Ações condicionais
+
+Use ações **Filtro** para:
+
+* Onboarding diferente para enterprise vs. SMB
+* Responsáveis diferentes com base na região
+* Ignorar notificações para negócios pequenos
+
+### Incluir detalhes da oferta
+
+Use a ação **Código** para formatar:
+
+* Documentos de resumo do negócio
+* Notas de repasse para a equipe de CS
+* Checklists de onboarding personalizadas
+
+## Relacionados
+
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Enviar e-mails a partir de Fluxos de Trabalho](/l/pt/user-guide/workflows/capabilities/send-emails-from-workflows)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/detect-stale-opportunities.mdx

@@ -0,0 +1,136 @@
+---
+title: Detectar oportunidades estagnadas
+description: Notifique automaticamente os gestores quando as oportunidades não tiverem sido atualizadas.
+---
+
+Mantenha o seu pipeline saudável alertando os gestores quando as oportunidades ficarem estagnadas. Este fluxo de trabalho verifica oportunidades que não foram atualizadas há um número específico de dias.
+
+## O Problema
+
+Oportunidades sem atualizações levam a:
+
+* Negócios a arrefecer
+* Previsões pouco fiáveis
+* Perda de receita
+
+## A Solução
+
+Crie um fluxo de trabalho agendado que encontre oportunidades estagnadas e envie e-mails aos respetivos gestores.
+
+## Configuração passo a passo
+
+### Etapa 1: Criar o fluxo de trabalho
+
+1. Vá para **Configurações → Fluxos de trabalho**
+2. Clique em **+ Novo fluxo de trabalho**
+3. Dê o nome "Alerta de Oportunidade Estagnada"
+
+### Etapa 2: Configurar o gatilho
+
+1. Selecione **Agendado**
+2. Defina para executar diariamente (por exemplo, todos os dias às 08:00)
+
+### Etapa 3: Pesquisar oportunidades estagnadas
+
+1. Adicione a ação **Pesquisar Registos**
+2. Configurar:
+
+| Campo      | Valor                                         |
+| ---------- | --------------------------------------------- |
+| **Objeto** | Oportunidades                                 |
+| **Filtro** | Atualizado em é anterior a (hoje - 7 dias)    |
+| **Filtro** | Fase não é "Closed Won" E não é "Closed Lost" |
+| **Limite** | 100                                           |
+
+### Etapa 4: Verificar se algum foi encontrado
+
+1. Adicione a ação **Filtro**
+2. Condição: `{{searchRecords.length}}` é maior do que 0
+3. Se não houver oportunidades estagnadas, o fluxo de trabalho termina aqui
+
+### Etapa 5: Formatar o alerta (Ação de Código)
+
+Adicione uma ação de **Código** para formatar o e-mail:
+
+```javascript
+export const main = async (params) => {
+  const opportunities = params.opportunities;
+
+  // Group opportunities by owner
+  const byOwner = {};
+  opportunities.forEach(opp => {
+    const ownerEmail = opp.owner?.email || 'unassigned';
+    if (!byOwner[ownerEmail]) {
+      byOwner[ownerEmail] = [];
+    }
+    byOwner[ownerEmail].push({
+      name: opp.name,
+      amount: opp.amount,
+      lastUpdated: opp.updatedAt,
+      stage: opp.stage
+    });
+  });
+
+  // Format summary for manager
+  let summary = "Stale Opportunities Report\n\n";
+  Object.entries(byOwner).forEach(([owner, opps]) => {
+    summary += `${owner}: ${opps.length} stale opportunities\n`;
+    opps.forEach(opp => {
+      summary += `  - ${opp.name} (${opp.stage})\n`;
+    });
+    summary += "\n";
+  });
+
+  return {
+    summary,
+    totalCount: opportunities.length
+  };
+};
+```
+
+### Etapa 6: Enviar e-mail de alerta
+
+Adicione a ação **Enviar e-mail**:
+
+| Campo       | Valor                                                                 |
+| ----------- | --------------------------------------------------------------------- |
+| **Para**    | sales-manager@yourcompany.com                                         |
+| **Assunto** | `🚨 {{code.totalCount}} oportunidades estagnadas precisam de atenção` |
+| **Corpo**   | `{{code.summary}}`                                                    |
+
+### Etapa 7: Testar e ativar
+
+1. Clique em **Testar** para executar o fluxo de trabalho
+2. Verifique se o e-mail contém os dados corretos
+3. Ative quando estiver pronto
+
+## Opções de personalização
+
+### Alterar o limite de estagnação
+
+Modifique o filtro de Pesquisar Registos para alterar de 7 dias para o período da sua preferência:
+
+* 3 dias para vendas de alto ritmo
+* 14 dias para negócios empresariais
+* 30 dias para ciclos de vendas longos
+
+### Alertar representantes individualmente
+
+Em vez de um e-mail único para o gestor, use **Iterator** para enviar e-mails personalizados a cada representante sobre os seus próprios negócios estagnados.
+
+### Adicionar escalonamento
+
+Crie vários fluxos de trabalho com gravidade crescente:
+
+1. Dia 7: E-mail para o representante
+2. Dia 14: E-mail para o representante + gestor
+3. Dia 21: Criar tarefa para o gestor intervir
+
+### Incluir no Slack
+
+Use **HTTP Request** para enviar para um webhook do Slack em vez de ou além do e-mail.
+
+## Relacionados
+
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Enviar e-mails a partir de Fluxos de Trabalho](/l/pt/user-guide/workflows/capabilities/send-emails-from-workflows)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/display-number-of-emails-received.mdx

@@ -0,0 +1,69 @@
+---
+title: Exibir o número de e-mails recebidos
+description: Crie um fluxo de trabalho para contar e exibir automaticamente o número de e-mails recebidos de cada contato.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<img src="/images/user-guide/workflows/workflow-number-of-emails-received.png" style={{width:'100%'}} />
+
+## Visão Geral
+
+Esse fluxo de trabalho é acionado sempre que um novo e-mail é recebido e atualiza um campo personalizado no registro de Pessoa com a contagem total de e-mails desse remetente.
+
+## Pré-requisitos
+
+Antes de configurar esse fluxo de trabalho, crie um campo personalizado no objeto **Pessoas**:
+
+1. Vá para **Configurações → Modelo de Dados → Pessoas**
+2. Adicione um novo campo **Número**
+3. Dê a ele um nome como "Número de e-mails recebidos desta pessoa"
+
+## Configuração passo a passo
+
+<VimeoEmbed videoId="1148700336" title="Demonstração em vídeo" />
+
+### Etapa 1: Configurar o gatilho
+
+1. Vá para **Fluxos de Trabalho** e crie um novo fluxo de trabalho
+2. Selecione **Registro é criado** como o gatilho
+3. Escolha **Participantes da Mensagem** (disponível em Objetos avançados)
+
+<Note>
+Um Participante da Mensagem é a combinação de um ID de mensagem e um ID de pessoa, criando um registro exclusivo por mensagem. Isso é mais fácil de acompanhar do que Mensagens diretamente porque podemos acessar o campo `handle`, que contém o endereço de e-mail do remetente (ou do destinatário).
+</Note>
+
+### Etapa 2: Filtrar por função
+
+1. Adicione a ação **Filtro**
+2. Defina a condição: **Role** igual a **FROM**
+
+Isso garante que você conte apenas as mensagens enviadas por essa pessoa, e não as mensagens enviadas para ela.
+
+### Etapa 3: Pesquisar todos os Participantes da Mensagem com o mesmo handle
+
+1. Adicione a ação **Pesquisar Registros**
+2. Selecione **Participantes da Mensagem** como o objeto
+3. Adicione filtros: **Handle** igual ao handle do gatilho (o endereço de e-mail do remetente) e **Role** igual a **FROM**
+4. Aumente o **Limite** de 1 para **200** (o máximo)
+
+Isso encontra todas as mensagens desse endereço de e-mail para obter a contagem total.
+
+<Note>
+A ação Pesquisar Registros é limitada a retornar no máximo 200 registros. No entanto, como você está usando apenas o valor `totalCount` (não os registros individuais), esta etapa retornará o número total de e-mails enviados por essa pessoa.
+</Note>
+
+### Etapa 4: Atualizar o registro de Pessoa com uma ação Criar ou Atualizar Registro
+
+1. Adicione a ação **Criar ou Atualizar Registro**
+2. Selecione **Pessoas** como o objeto
+3. Encontre a pessoa cujo e-mail corresponde ao `handle` do Participante da Mensagem
+4. Defina seu campo personalizado "Número de e-mails recebidos" como `{{searchRecords.totalCount}}`
+
+O valor `totalCount` da ação Pesquisar Registros representa o número total de e-mails recebidos dessa pessoa.
+
+## Relacionados
+
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Criar campos personalizados](/l/pt/user-guide/data-model/how-tos/customize-your-data-model)
+* [Ação Pesquisar Registros](/l/pt/user-guide/workflows/capabilities/workflow-actions#search-records)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/display-related-record-data.mdx

@@ -0,0 +1,170 @@
+---
+title: Apresentar dados de registos relacionados
+description: Mostrar dados de registos relacionados (por exemplo, informações da Empresa em Oportunidades) usando fluxos de trabalho.
+---
+
+Apresente dados de registos relacionados diretamente nos seus registos — por exemplo, mostre o número de funcionários de uma Empresa nas suas Oportunidades. Esta solução alternativa com fluxos de trabalho é útil até que os campos aninhados estejam disponíveis nativamente.
+
+## Casos de Uso Comuns
+
+| Fonte        | Destino      | Campos a Copiar                                         |
+| ------------ | ------------ | ------------------------------------------------------- |
+| Empresa      | Oportunidade | Setor, Tamanho da Empresa, ARR                          |
+| Pessoa       | Oportunidade | Email, Telefone, Cargo                                  |
+| Oportunidade | Empresa      | Valor do Último Negócio, Data do Último Negócio Ganhado |
+
+## Cópia Básica de Campo
+
+### Exemplo: Copiar Email do Contacto para a Oportunidade
+
+**Objetivo**: Ao definir um Ponto de Contacto numa oportunidade, copiar o email dessa pessoa para a oportunidade para acesso facilitado.
+
+### Pré-requisito
+
+Crie os campos de destino em **Definições → Modelo de Dados → Oportunidades** antes de construir o fluxo de trabalho:
+
+* Email do Contacto (tipo: Email)
+* Telefone do Contacto (tipo: Telefone)
+
+### Configuração
+
+1. **Gatilho**: Registo é atualizado (Oportunidades, campo Ponto de Contacto)
+
+2. **Filtro**: Verificar que o Ponto de Contacto não está vazio
+
+3. **Pesquisar Registos**: Encontrar a pessoa associada
+   * Objeto: Pessoas
+   * Filtro: ID igual a `{{trigger.object.pointOfContact.id}}`
+
+4. **Atualizar Registo**:
+   * Objeto: Oportunidades
+   * Registo: `{{trigger.object.id}}`
+   * Email do Contacto: `{{searchRecords[0].email}}`
+   * Telefone do Contacto: `{{searchRecords[0].phone}}`
+
+## Copiar Vários Campos
+
+### Exemplo: Sincronizar Informações da Empresa com Todas as Oportunidades Relacionadas
+
+**Objetivo**: Quando os detalhes da empresa mudarem, atualizar todas as oportunidades relacionadas.
+
+### Configuração
+
+1. **Gatilho**: Registo é atualizado (Empresas)
+   * Campos: Setor, Tamanho da Empresa, Receita Anual
+
+2. **Pesquisar Registos**: Encontrar todas as oportunidades desta empresa
+   * Objeto: Oportunidades
+   * Filtro: ID da Empresa igual a `{{trigger.object.id}}`
+
+3. **Iterador**: Percorrer cada oportunidade
+
+4. **Atualizar Registo** (dentro do iterador):
+   * Objeto: Oportunidades
+   * Registo: `{{iterator.currentItem.id}}`
+   * Setor da Empresa: `{{trigger.object.industry}}`
+   * Tamanho da Empresa: `{{trigger.object.companySize}}`
+   * ARR da Empresa: `{{trigger.object.annualRevenue}}`
+
+## Copiar na Criação do Registo
+
+### Exemplo: Preencher a Oportunidade com Dados da Empresa
+
+**Objetivo**: Ao criar uma oportunidade vinculada a uma empresa, copiar automaticamente as informações principais da empresa.
+
+### Pré-requisito
+
+Crie os campos de destino em **Definições → Modelo de Dados → Oportunidades**:
+
+* Setor da Empresa (tipo: Texto)
+* Tamanho da Empresa (tipo: Número)
+
+### Configuração
+
+1. **Gatilho**: Registo é criado (Oportunidades)
+   * Filtro: Empresa não está vazia
+
+2. **Pesquisar Registos**: Obter os detalhes da empresa associada
+   * Objeto: Empresas
+   * Filtro: ID igual a `{{trigger.object.company.id}}`
+
+3. **Atualizar Registo**:
+   * Objeto: Oportunidades
+   * Registo: `{{trigger.object.id}}`
+   * Setor da Empresa: `{{searchRecords[0].industry}}`
+   * Tamanho da Empresa: `{{searchRecords[0].employees}}`
+
+<Note>
+**Limitação de Tarefas e Notas**: As relações em Tarefas e Notas são pré-definidas como muitos-para-muitos e ainda não estão disponíveis em gatilhos ou ações de fluxos de trabalho. Para aceder a estas relações, use antes a [API](/l/pt/developers/extend/api).
+</Note>
+
+## Sincronização Bidirecional
+
+### Exemplo: Manter o Contacto Principal Sincronizado
+
+**Objetivo**: Quando o contacto principal de uma empresa mudar, atualizar o contacto. Quando uma pessoa se tornar principal, atualizar a empresa.
+
+### Fluxo de Trabalho 1: Empresa → Pessoa
+
+1. **Gatilho**: Registo é atualizado (Empresas, campo Contacto Principal)
+2. **Atualizar Registo**: Definir "É Contacto Principal" da pessoa como verdadeiro
+3. **Pesquisar Registos**: Encontrar o contacto principal anterior
+4. **Atualizar Registo**: Definir "É Contacto Principal" do contacto anterior como falso
+
+### Fluxo de Trabalho 2: Pessoa → Empresa
+
+1. **Gatilho**: Registo é atualizado (Pessoas, É Contacto Principal = verdadeiro)
+2. **Atualizar Registo**: Definir o Contacto Principal da empresa para esta pessoa
+
+<Note>
+Tenha cuidado com sincronizações bidirecionais para evitar ciclos infinitos. Use filtros para verificar se o valor realmente mudou antes de atualizar.
+</Note>
+
+## Usar Código para Mapeamento Complexo
+
+### Exemplo: Transformar Dados Durante a Cópia
+
+**Objetivo**: Copiar e formatar o número de telefone da pessoa para a oportunidade.
+
+```javascript
+export const main = async (params) => {
+  const { phone } = params;
+
+  if (!phone) return { formattedPhone: null };
+
+  // Remove non-numeric characters
+  const digits = phone.replace(/\D/g, '');
+
+  // Format as (XXX) XXX-XXXX
+  const formatted = digits.length === 10
+    ? `(${digits.slice(0,3)}) ${digits.slice(3,6)}-${digits.slice(6)}`
+    : phone;
+
+  return { formattedPhone: formatted };
+};
+```
+
+## Melhores Práticas
+
+### Evitar Ciclos
+
+* Não crie fluxos de trabalho que disparem uns aos outros indefinidamente
+* Use condições específicas de campo
+* Adicione verificações para ver se o valor realmente mudou
+
+### Tratar Dados em Falta
+
+* Verifique sempre se o registo de origem existe antes de copiar
+* Forneça valores predefinidos para campos opcionais
+* Use filtros para ignorar quando o campo de origem estiver vazio
+
+### Desempenho
+
+* Agrupe atualizações ao copiar para muitos registos
+* Use fluxos de trabalho agendados para operações de sincronização em massa
+* Considere usar o Iterador para atualizações de múltiplos registos
+
+## Relacionados
+
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/formula-fields.mdx

@@ -0,0 +1,202 @@
+---
+title: Campos de Fórmula
+description: Crie campos de fórmula usando fluxos de trabalho até que o suporte nativo esteja disponível.
+---
+
+A Twenty ainda não oferece suporte nativo a campos de fórmula (chegando em 2026), mas você pode obter o mesmo resultado usando fluxos de trabalho. Esta solução alternativa permite calcular e preencher automaticamente os valores dos campos — de concatenações simples a lógica de negócios complexa.
+
+## Casos de Uso Comuns
+
+| Caso de uso               | Exemplo de fórmula                  |
+| ------------------------- | ----------------------------------- |
+| **Nome completo**         | Nome + " " + Sobrenome              |
+| **Valor esperado**        | Valor × Probabilidade               |
+| **Dias até o vencimento** | Data de vencimento - hoje           |
+| **Dias na etapa**         | Hoje - Data de entrada na etapa     |
+| **Pontuação de lead**     | Pontos com base em vários critérios |
+
+<Tip>
+Para um exemplo completo de rastreamento do tempo nas etapas do pipeline, consulte [Acompanhar por quanto tempo as oportunidades permanecem em cada etapa](/l/pt/user-guide/views-pipelines/how-tos/track-time-in-stage).
+</Tip>
+
+## Fórmula básica: Concatenação
+
+### Exemplo: Preencher automaticamente o nome completo
+
+**Objetivo**: Combinar automaticamente nome e sobrenome em um campo de nome completo.
+
+### Configuração
+
+1. **Gatilho**: Registro é atualizado ou criado (Pessoas)
+
+2. **Filtro**: Verifique se o nome ou o sobrenome foi alterado
+
+3. **Ação de código**:
+
+```javascript
+export const main = async (params) => {
+  const { firstName, lastName } = params;
+
+  const fullName = [firstName, lastName]
+    .filter(Boolean)
+    .join(' ');
+
+  return { fullName };
+};
+```
+
+4. **Atualizar registro**: Definir Nome completo como `{{code.fullName}}`
+
+## Fórmula numérica: Valor esperado
+
+### Exemplo: Calcular a receita esperada
+
+**Objetivo**: Multiplicar o valor da oportunidade pela probabilidade para obter o valor esperado.
+
+Consulte [Como mostrar o valor esperado no pipeline](/l/pt/user-guide/views-pipelines/how-tos/show-expected-amount-in-pipeline) para o fluxo de trabalho completo.
+
+### Configuração
+
+1. **Gatilho**: Registro é atualizado (Oportunidades, campo Valor OU Probabilidade)
+
+2. **Ação de código**:
+
+```javascript
+export const main = async (params) => {
+  const { amount, probability } = params;
+
+  const expectedAmount = (amount || 0) * (probability || 0) / 100;
+
+  return { expectedAmount };
+};
+```
+
+3. **Atualizar registro**: Definir Valor esperado como `{{code.expectedAmount}}`
+
+## Fórmula de data: Cálculo de dias
+
+### Exemplo: Dias até o vencimento da tarefa
+
+**Objetivo**: Calcular quantos dias faltam até a data de vencimento de uma tarefa.
+
+### Configuração
+
+1. **Gatilho**: Registro é atualizado ou criado (Tarefas, campo Data de vencimento)
+
+2. **Ação de código**:
+
+```javascript
+export const main = async (params) => {
+  const { dueDate } = params;
+
+  if (!dueDate) {
+    return { daysUntilDue: null };
+  }
+
+  const due = new Date(dueDate);
+  const today = new Date();
+  const diffTime = due - today;
+  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+
+  return { daysUntilDue: diffDays };
+};
+```
+
+3. **Atualizar registro**: Definir Dias até o vencimento como `{{code.daysUntilDue}}`
+
+<Note>
+Valores negativos indicam tarefas em atraso. Você pode usar este campo para filtrar ou classificar tarefas por urgência.
+</Note>
+
+## Fórmula condicional: Pontuação de lead
+
+### Exemplo: Calcular a pontuação de lead com base em critérios
+
+**Objetivo**: Pontuar leads com base no porte da empresa, setor e engajamento.
+
+### Configuração
+
+1. **Gatilho**: Registro é atualizado (Pessoas ou Empresas)
+
+2. **Ação de código**:
+
+```javascript
+export const main = async (params) => {
+  const { companySize, industry, hasEmail, hasPhone, source } = params;
+
+  let score = 0;
+
+  // Company size scoring
+  if (companySize === 'Enterprise') score += 30;
+  else if (companySize === 'Mid-Market') score += 20;
+  else if (companySize === 'SMB') score += 10;
+
+  // Industry scoring
+  const targetIndustries = ['Technology', 'Finance', 'Healthcare'];
+  if (targetIndustries.includes(industry)) score += 25;
+
+  // Contact info scoring
+  if (hasEmail) score += 10;
+  if (hasPhone) score += 15;
+
+  // Source scoring
+  if (source === 'Referral') score += 20;
+  else if (source === 'Website') score += 10;
+
+  return { leadScore: score };
+};
+```
+
+3. **Atualizar registro**: Definir Pontuação de lead como `{{code.leadScore}}`
+
+## Fórmula de texto: Extração de domínio
+
+### Exemplo: Extrair domínio do e-mail
+
+**Objetivo**: Extrair e armazenar automaticamente o domínio do e-mail.
+
+### Configuração
+
+1. **Gatilho**: Registro é atualizado (Pessoas, campo E-mail)
+
+2. **Ação de código**:
+
+```javascript
+export const main = async (params) => {
+  const { email } = params;
+
+  if (!email) return { domain: null };
+
+  const domain = email.split('@')[1]?.toLowerCase();
+
+  return { domain };
+};
+```
+
+3. **Atualizar registro**: Definir o campo Domínio como `{{code.domain}}`
+
+## Melhores Práticas
+
+### Desempenho
+
+* Acione apenas em alterações de campos relevantes
+* Use filtros para ignorar registros que não precisam de cálculo
+* Evite cálculos complexos em fluxos de trabalho de alto volume
+
+### Tratamento de Erros
+
+* Verifique valores null/undefined antes dos cálculos
+* Use valores padrão quando faltarem dados
+* Retorne mensagens de erro claras quando os cálculos falharem
+
+### Testes
+
+* Teste com casos extremos (campos vazios, valores zero)
+* Verifique os cálculos manualmente antes de ativar
+* Monitore as execuções de fluxos de trabalho para resultados inesperados
+
+## Relacionados
+
+* [Como mostrar o valor esperado no pipeline](/l/pt/user-guide/views-pipelines/how-tos/show-expected-amount-in-pipeline)
+* [Como acompanhar o tempo na etapa](/l/pt/user-guide/views-pipelines/how-tos/track-time-in-stage)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/notify-teammates-of-note-to-review.mdx

@@ -0,0 +1,127 @@
+---
+title: Notificar colegas de equipe sobre uma nota para revisão
+description: Envie notificações automáticas por e-mail ao atribuir um colega para revisar uma nota.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<Note>
+**Marcar colegas diretamente nas notas ainda não é suportado.** Esse recurso está planejado para o segundo semestre de 2026. Enquanto isso, este fluxo de trabalho oferece uma solução alternativa prática.
+</Note>
+
+## O desafio
+
+Você quer marcar um colega em uma nota para que receba uma notificação para revisá-la. Hoje, a Twenty não oferece suporte a @mentions em notas ou tarefas.
+
+## A solução alternativa
+
+Em vez de marcar no texto da nota, você pode:
+
+1. Crie um campo de relação **Revisor** no objeto Notas
+2. Atribua o revisor ao criar ou editar a nota
+3. Ter um fluxo de trabalho automaticamente enviar um e-mail ao revisor com um link para a nota
+
+<Warning>
+**Limitação**: Esta abordagem permite atribuir um revisor por campo. Se você precisar notificar várias pessoas, crie campos de relação adicionais (por exemplo, Revisor 1, Revisor 2). Isso não escala bem se você precisar marcar muitos colaboradores de uma só vez.
+</Warning>
+
+## Configuração passo a passo
+
+### Etapa 1: Criar o campo Revisor
+
+<img src="/images/user-guide/workflows/reviewer-field-for-note.png" style={{width:'100%'}} />
+
+1. Vá para **Configurações → Modelo de Dados → Notas**
+2. Clique em **Adicionar campo**
+3. Configurar:
+
+| Configuração           | Valor                                          |
+| ---------------------- | ---------------------------------------------- |
+| **Nome**               | Revisor                                        |
+| **Tipo**               | Relação                                        |
+| **Objeto Relacionado** | Membro do Workspace                            |
+| **Tipo de Relação**    | Muitas Notas → Um Membro do Espaço de Trabalho |
+
+4. Salve o campo
+
+### Etapa 2: Criar o fluxo de trabalho
+
+<VimeoEmbed videoId="1151897168" title="Demonstração em vídeo" />
+
+#### Criar o gatilho do fluxo de trabalho
+
+1. Vá para a visualização principal e crie um novo fluxo de trabalho
+2. Selecione **Registro atualizado** como o gatilho
+3. Escolha **Nota** como o objeto e especifique o campo Revisor.
+4. Isso será acionado sempre que o revisor de uma nota for atualizado.
+
+#### Adicione um filtro para verificar se o revisor acabou de ser atribuído
+
+Adicione uma ação de **Filtro** para garantir que o fluxo de trabalho só continue quando um revisor for atribuído:
+
+| Condição    | Valor          |
+| ----------- | -------------- |
+| **Revisor** | não está vazio |
+
+#### Pesquisar o Membro do Espaço de Trabalho
+
+1. Adicione uma ação **Pesquisar Registros**
+2. Selecione **Membro do Espaço de Trabalho** (em Objetos Avançados)
+3. Adicione um filtro:
+
+| Condição | Valor                           |
+| -------- | ------------------------------- |
+| **ID**   | é igual a `{{note.reviewerId}}` |
+
+Isso recupera o registro completo do membro do espaço de trabalho, incluindo seu endereço de e-mail e nome.
+
+#### Enviar o e-mail de notificação
+
+1. Adicione uma ação **Enviar e-mail**
+2. Configurar:
+
+| Campo       | Valor                                                                            |
+| ----------- | -------------------------------------------------------------------------------- |
+| **Para**    | Registro de pesquisa → Primeiro Membro do Espaço de Trabalho → E-mail do usuário |
+| **Assunto** | Uma nota precisa da sua revisão                                                  |
+| **Corpo**   | Veja o exemplo abaixo                                                            |
+
+**Exemplo de corpo do e-mail:**
+
+```text
+Hi {{searchRecord.firstWorkspaceMember.name.firstName}},
+
+You've been assigned to review a note.
+
+View the note here:
+https://yourSubDomain.twenty.com/object/note/{{recordIsUpdated.id}}
+
+Best,
+Twenty
+```
+
+<Note>
+Substitua `yourSubDomain` pelo subdomínio real do seu espaço de trabalho Twenty.
+</Note>
+
+#### Testar e ativar
+
+1. Clique em **Testar** para executar o fluxo de trabalho manualmente
+2. Crie ou edite uma nota e atribua um revisor
+3. Verifique a caixa de entrada do revisor para o e-mail de notificação
+4. Ative o fluxo de trabalho
+
+## Uso
+
+Depois de configurado, sua equipe pode usar este fluxo de trabalho:
+
+1. Criando uma nova nota (ou editando uma existente)
+2. Selecionando um colega no campo **Revisor**
+3. O colega recebe automaticamente um e-mail com um link direto para a nota
+
+## Relacionados
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Enviar e-mails a partir de Fluxos de Trabalho](/l/pt/user-guide/workflows/capabilities/send-emails-from-workflows)
+* [Criar campos personalizados](/l/pt/user-guide/data-model/how-tos/create-custom-fields)
+* [Criar campos de relação](/l/pt/user-guide/data-model/how-tos/create-relation-fields)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/crm-automations/send-email-alerts-with-tasks-due.mdx

@@ -0,0 +1,106 @@
+---
+title: Enviar alertas por e-mail sobre tarefas com vencimento
+description: Notifique automaticamente os membros da equipe sobre suas tarefas próximas ou em atraso.
+---
+
+import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';
+
+<img src="/images/user-guide/workflows/email_tasks_due.png" style={{width:'100%'}} />
+
+Envie lembretes diários por e-mail para cada membro da equipe sobre suas tarefas com vencimento hoje.
+
+## Visão Geral
+
+Este fluxo de trabalho é executado conforme um cronograma e:
+
+1. Busca todos os membros do espaço de trabalho
+2. Percorre cada membro
+3. Localiza suas tarefas com vencimento hoje
+4. Formata e envia um e-mail personalizado
+
+## Configuração passo a passo
+
+<VimeoEmbed videoId="1147463514" title="Demonstração em vídeo" />
+
+### Etapa 1: Configurar o gatilho
+
+1. Vá até **Configurações → Fluxos de Trabalho** e crie um novo fluxo de trabalho
+2. Selecione **Agendado** como o gatilho
+3. Use uma expressão cron para executar diariamente às 8:00: `0 8 * * *`
+
+### Etapa 2: Pesquisar todos os membros do espaço de trabalho
+
+1. Adicione a ação **Pesquisar Registros**
+2. Selecione **Membros do Espaço de Trabalho** (em objetos avançados)
+3. Não são necessários filtros — isso retorna todos os membros
+
+### Etapa 3: Adicionar um Iterador
+
+1. Adicione a ação **Iterador**
+2. Defina o array de entrada como os membros do espaço de trabalho da etapa anterior
+3. Todas as ações dentro do iterador serão executadas uma vez por membro
+
+### Etapa 4: Pesquisar tarefas com vencimento hoje (dentro do iterador)
+
+1. Dentro do iterador, adicione a ação **Pesquisar Registros**
+2. Selecione **Tarefas** como o objeto
+3. Adicione filtros:
+   * **Responsável** = membro atual do espaço de trabalho (do iterador)
+   * **Data de vencimento** = hoje
+
+### Etapa 5: Formatar as tarefas no corpo do e-mail (dentro do iterador)
+
+Adicione uma ação **Código** para formatar as tarefas em uma lista legível com links:
+
+```javascript
+export const main = async (params: {
+  tasksDue?: Array<{ id: string; title: string }> | null | string;
+}) => {
+  const tasksDue =
+    typeof params.tasksDue === "string"
+      ? JSON.parse(params.tasksDue)
+      : params.tasksDue;
+
+  if (!Array.isArray(tasksDue) || tasksDue.length === 0) {
+    return {
+      formattedTasks: "No tasks due today."
+    };
+  }
+
+  const formattedTasks = tasksDue
+    .map(
+      t =>
+        `${t.title}\nhttps://yourSubDomain.twenty.com/object/task/${t.id}`
+    )
+    .join("\n\n");
+
+  return { formattedTasks };
+};
+```
+
+<Note>
+Substitua `yourSubDomain` pelo subdomínio real do seu espaço de trabalho Twenty.
+</Note>
+
+### Etapa 6: Enviar E-mail (dentro do iterador)
+
+1. Adicione a ação **Enviar E-mail** (ainda dentro do iterador)
+2. Configurar:
+
+| Campo       | Valor                                                                         |
+| ----------- | ----------------------------------------------------------------------------- |
+| **Para**    | `{{iterator.currentItem.userEmail}}` (e-mail do membro do espaço de trabalho) |
+| **Assunto** | Suas tarefas com vencimento hoje                                              |
+| **Corpo**   | `{{code.formattedTasks}}`                                                     |
+
+### Etapa 7: Testar e ativar
+
+1. Clique em **Testar** para executar o fluxo de trabalho manualmente
+2. Verifique as caixas de entrada para os e-mails
+3. Ative o fluxo de trabalho
+
+## Relacionados
+
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Enviar e-mails a partir de Fluxos de Trabalho](/l/pt/user-guide/workflows/capabilities/send-emails-from-workflows)
+* [Lidar com arrays em ações de código](/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions)

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/need-more-help/professional-services.mdx

@@ -0,0 +1,21 @@
+---
+title: Serviços Profissionais
+description: Obtenha ajuda profissional para construir fluxos de trabalho complexos e automações com a equipe do Twenty e parceiros certificados.
+---
+
+## Quando Você Precisa de Ajuda Profissional?
+
+Considere serviços profissionais para:
+
+* Integrações complexas de múltiplos sistemas
+* Lógica de negócios avançada e regras de automação
+* Fluxos de trabalho de processamento de dados em larga escala
+* Desenvolvimento de API personalizado
+* Treinamento de equipe e otimização de fluxo de trabalho
+* Quando você não tem recursos internos
+
+## Opções de Serviço
+
+### Parceiros de Implementação
+
+Trabalhe com parceiros certificados para personalizações avançadas. Contacte-nos em [contact@twenty.com](mailto:contact@twenty.com) para entrar em contacto com os nossos [parceiros de implementação](https://twenty.com/partners).

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/need-more-help/workflow-troubleshooting.mdx

@@ -0,0 +1,170 @@
+---
+title: Solução de Problemas do Workflow
+description: Problemas comuns de fluxos de trabalho e como resolvê-los.
+---
+
+## Problemas Comuns e Soluções
+
+### Workflow Não Dispara
+
+**Sintomas**: Seu fluxo de trabalho não é executado quando você espera.
+
+**Possíveis causas**:
+
+1. **Fluxo de trabalho não ativado**: Garanta que o fluxo de trabalho esteja definido como "Active", não "Draft"
+2. **Condições do gatilho não atendidas**: Verifique se o gatilho corresponde ao evento esperado
+3. **Campo não monitorado**: Para gatilhos "Record is Updated", garanta que o campo específico esteja sendo monitorado
+4. **Permissões**: Verifique se você tem permissão para executar fluxos de trabalho
+
+**Soluções**:
+
+* Verifique o status do fluxo de trabalho na lista de fluxos de trabalho
+* Teste com a ação específica que você espera que o dispare
+* Revise a configuração do gatilho
+* Entre em contato com o seu administrador sobre permissões
+
+### Gatilhos do fluxo de trabalho ocorrem cedo demais (campos vazios)
+
+**Sintomas**: Ao criar um registro manualmente na interface do usuário (UI), o seu fluxo de trabalho é acionado antes de você ter tempo de preencher todos os campos. O fluxo de trabalho é executado com a maioria dos campos vazios.
+
+**Por que isso acontece**: Twenty salva tudo em tempo real — não há um modo separado de "edit" vs "read". Quando você cria um registro, ele é salvo imediatamente, acionando o evento "Record is created" antes de você preencher os campos adicionais.
+
+**Quando "Record is created" funciona bem**:
+
+* Registros criados por chamadas de API (os campos são preenchidos em uma única requisição)
+* Registros criados por importação
+* Criação automática de registros a partir de outros fluxos de trabalho
+
+**Solução**: Para registros criados manualmente na UI, use **"Record is created or updated"** como seu gatilho em vez disso. Dessa forma:
+
+* O fluxo de trabalho é acionado depois que o usuário termina de preencher e salvar os campos
+* Você obtém os dados completos em vez de valores vazios
+
+<Tip>
+Se você quer que o fluxo de trabalho seja executado apenas uma vez por registro, adicione uma ação Filter para verificar um campo como `createdAt equals updatedAt` (primeiro salvamento) ou use um campo de caixa de seleção personalizado para acompanhar se o fluxo de trabalho já foi executado.
+</Tip>
+
+### Ações com falha
+
+**Sintomas**: O fluxo de trabalho é executado, mas algumas ações falham.
+
+**Possíveis causas**:
+
+1. **Dados ausentes**: Campos obrigatórios estão vazios
+2. **Referências inválidas**: Variáveis de etapas anteriores não existem
+3. **Erros de API**: Serviços externos retornando erros
+4. **Problemas de permissão**: A ação requer permissões que você não possui
+
+**Soluções**:
+
+* Verifique os detalhes da execução do fluxo de trabalho em busca de mensagens de erro
+* Verifique se todos os campos obrigatórios têm valores
+* Teste as conexões de API de forma independente
+* Revise as permissões de função
+
+### Erros de requisição HTTP
+
+**Sintomas**: Ações de requisição HTTP falham ou retornam resultados inesperados.
+
+**Códigos de erro comuns**:
+
+* **400**: Solicitação inválida - verifique o formato do corpo da requisição
+* **401**: Não autorizado - verifique a chave da API
+* **403**: Proibido - verifique as permissões da API
+* **404**: Não encontrado - verifique a URL do endpoint
+* **429**: Muitas requisições - implemente limitação de taxa
+* **500**: Erro do servidor - problema no serviço externo
+
+**Soluções**:
+
+* Verifique a URL do endpoint da API
+* Verifique os cabeçalhos de autenticação
+* Teste a chamada de API primeiro fora do Twenty
+* Adicione tratamento de erros em Ações de Código
+
+### Erros em Ações de Código
+
+**Sintomas**: O código JavaScript não é executado.
+
+**Problemas comuns**:
+
+1. **Erros de sintaxe**: Erros de digitação ou JavaScript inválido
+2. **Variáveis indefinidas**: Referenciando variáveis que não existem
+3. **Erros de tipo**: Operações com tipos de dados incorretos
+4. **Tempo limite excedido**: Código demorando muito para executar
+
+**Soluções**:
+
+* Use a validação integrada do editor de código
+* Teste a lógica do código primeiro em um console JavaScript
+* Adicione instruções console.log para depuração
+* Simplifique operações complexas
+
+### E-mail não enviado
+
+**Sintomas**: A ação Send Email não entrega os e-mails.
+
+**Possíveis causas**:
+
+1. **Nenhuma conta de e-mail conectada**: Verifique Configurações → Contas
+2. **Endereço de e-mail inválido**: O e-mail do destinatário está com formato inválido
+3. **Limites de envio**: Limites de taxa do provedor de e-mail atingidos
+4. **Filtros de spam**: E-mails sendo bloqueados
+
+**Soluções**:
+
+* Verifique a conexão da conta de e-mail
+* Valide os endereços de e-mail dos destinatários
+* Verifique os limites do provedor de e-mail
+* Revise o conteúdo do e-mail para gatilhos de spam
+
+## Depuração de fluxos de trabalho
+
+### Usando execuções de fluxo de trabalho
+
+1. Vá para o editor de fluxo de trabalho
+2. Abra o painel **Runs**
+3. Encontre a execução com falha
+4. Clique para ver os detalhes passo a passo
+5. Revise as mensagens de erro e os dados de saída
+
+### Testando etapas individuais
+
+1. Para Ações de Código, use o botão **Test**
+2. Para requisições HTTP, teste o endpoint separadamente
+3. Crie registros de teste para acionar fluxos de trabalho
+4. Use gatilhos manuais para testes controlados
+
+### Padrões comuns de depuração
+
+**Adicione logs**:
+Use Ações de Código para registrar valores intermediários para depuração.
+
+**Isole etapas**:
+Teste cada etapa de forma independente para identificar falhas.
+
+**Verifique o fluxo de dados**:
+Confirme que cada etapa recebe os dados de entrada esperados.
+
+## Boas práticas para evitar problemas
+
+### Antes da ativação
+
+* Teste cuidadosamente no modo de rascunho
+* Valide todas as conexões de API
+* Revise cuidadosamente as condições do gatilho
+* Documente o comportamento esperado
+
+### Durante o desenvolvimento
+
+* Use nomes descritivos para as etapas
+* Adicione comentários nas Ações de Código
+* Teste com dados realistas
+* Planeje casos-limite
+
+### Após a ativação
+
+* Monitore de perto as execuções iniciais
+* Configure alertas para falhas
+* Revise regularmente o histórico de execuções
+* Mantenha os fluxos de trabalho simples quando possível

packages/twenty-docs/l/pt/user-guide/workflows/how-tos/need-more-help/workflows-faq.mdx

@@ -0,0 +1,236 @@
+---
+title: Perguntas frequentes sobre fluxos de trabalho
+description: Perguntas frequentes sobre fluxos de trabalho na Twenty.
+---
+
+<AccordionGroup>
+
+  <Accordion title="Por que não consigo ativar um fluxo de trabalho?">
+    Isso provavelmente é um problema de permissões. Você precisa de acesso a fluxos de trabalho para criá-los e ativá-los.
+
+    **Solução**: Entre em contato com o administrador do seu espaço de trabalho para conceder acesso a fluxos de trabalho em **Configurações → Membros → Funções**.
+
+    Se você não vê a seção de fluxos de trabalho na sua barra lateral, isso confirma que é um problema de permissões.
+  </Accordion>
+
+  <Accordion title="Por que não vejo o botão do meu fluxo de trabalho manual na barra de navegação superior?">
+    Fluxos de trabalho manuais só aparecem na barra de navegação se estiverem corretamente configurados:
+
+    1. O fluxo de trabalho deve estar **ativado** (não em modo rascunho)
+    2. A posição na barra de navegação deve estar definida como **Pinned**
+    3. Para gatilhos Single/Bulk, você deve estar na página do objeto correta
+
+    **Para verificar**: Abra o fluxo de trabalho → clique no gatilho → verifique se "Navbar placement" está definido como "Pinned".
+
+    Você sempre pode acessar fluxos de trabalho manuais via **Cmd + K** (ou **Ctrl + K**), independentemente das configurações da barra de navegação.
+  </Accordion>
+
+  <Accordion title="Qual é a diferença entre gatilhos manuais Single, Global e Bulk?">
+    | Tipo | Registros necessários | Execuções de Workflow |
+    | ---- | --------------------- | --------------------- |
+    \| **Global** | Nenhum | Uma vez, sem entrada de registro |
+    \| **Single** | Um ou mais selecionados | Uma vez por registro selecionado |
+    \| **Bulk** | Um ou mais selecionados | Uma vez, com todos os registros como array |
+
+    * **Global**: Use quando o fluxo de trabalho não precisa de nenhum contexto de registro (por exemplo, gerar um relatório)
+    * **Single**: Use quando você quer processar cada registro selecionado de forma independente (por exemplo, enviar e-mails individuais)
+    * **Bulk**: Use quando você precisa processar registros em conjunto ou otimizar o uso de créditos (requer a ação Iterator)
+
+    Veja [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers) para obter detalhes.
+  </Accordion>
+
+  <Accordion title="Não vejo um nó If/Else. O que devo fazer?">
+    Um nó If/Else explícito ainda não está disponível, mas está em nosso roadmap.
+
+    **Solução alternativa atual**: Crie várias ramificações a partir da sua etapa, cada uma começando com uma ação **Filter**:
+
+    ```
+    Step 1
+       │
+       ├── Branch A: Filter (condition = true) → Actions...
+       │
+       └── Branch B: Filter (condition = false) → Actions...
+    ```
+
+    Apenas a ramificação em que a condição do filtro for atendida executará suas ações subsequentes.
+
+    Veja [Como usar ramificações](/l/pt/user-guide/workflows/capabilities/workflow-branches) para um guia passo a passo.
+  </Accordion>
+
+  <Accordion title="As ramificações do fluxo de trabalho são executadas em paralelo?">
+    **Sim**, as ramificações são executadas em paralelo por padrão.
+
+    Se você quiser que apenas uma ramificação seja executada:
+    * Adicione uma ação **Filter** no início de cada ramificação
+    * Defina condições opostas (por exemplo, Ramificação A: status = "Open", Ramificação B: status ≠ "Open")
+
+    Ramificações que não atendem à sua condição de filtro param de executar, enquanto as outras continuam.
+  </Accordion>
+
+  <Accordion title="Posso unir as ramificações novamente?">
+    **Sim**. Após a conclusão das ramificações em paralelo, você pode adicionar uma etapa à qual ambas as ramificações se conectam.
+
+    No editor de fluxo de trabalho:
+    1. Conclua suas ações ramificadas
+    2. Adicione uma nova etapa após as ramificações
+    3. Arraste conexões do final de cada ramificação para essa nova etapa
+
+    A etapa mesclada será executada após a conclusão de todas as ramificações conectadas.
+  </Accordion>
+
+  <Accordion title="Qual é o limite nos resultados de Search Records?">
+    **Search Records retorna no máximo 200 registros.**
+
+    Se você precisar processar mais:
+    * Adicione filtros mais específicos para reduzir os resultados
+    * Use fluxos de trabalho agendados para processar em lotes
+    * Considere usar a API para operações em massa
+
+    Para a maioria dos fluxos de trabalho, 200 registros são suficientes. Se você atingir esse limite regularmente, considere reestruturar sua automação.
+  </Accordion>
+
+  <Accordion title="Posso adicionar pessoas em CC nos e-mails do fluxo de trabalho?">
+    **Ainda não.** Os campos CC e BCC para a ação Send Email estão em nosso roadmap.
+
+    **Solução alternativa atual**: Adicione várias ações Send Email para enviar a destinatários adicionais, ou use um HTTP Request para enviar por meio de um serviço de e-mail externo que dê suporte a CC.
+  </Accordion>
+
+  <Accordion title="Como uso as saídas de etapas anteriores?">
+    Cada ação produz dados de saída que podem ser usados em etapas subsequentes.
+
+    **Para referenciar dados de etapas anteriores**:
+    * Use o seletor de variáveis ao configurar um campo
+    * Ou digite `{{stepName.fieldName}}` diretamente
+
+    **Exemplos**:
+    * Dados do gatilho: `{{trigger.object.email}}`
+    * Resultados da pesquisa: `{{searchRecords[0].name}}`
+    * Saída do código: `{{code.calculatedValue}}`
+
+    Passe o mouse sobre qualquer campo na configuração da ação para ver as variáveis disponíveis das etapas anteriores.
+  </Accordion>
+
+  <Accordion title="Por que meu Iterator falha?">
+    **Iterator requer uma entrada do tipo array.** Problemas comuns:
+
+    1. **A entrada não é um array**: garanta que você está passando resultados de Search Records ou outra ação que retorne um array
+    2. **O array está vazio**: adicione um filtro antes do Iterator para verificar `{{searchRecords.length}} > 0`
+    3. **Variável errada selecionada**: certifique-se de selecionar o próprio array, não um único registro
+
+    **Configuração correta**:
+    1. Search Records (retorna um array)
+    2. Filter: length > 0
+    3. Iterator: selecione `{{searchRecords}}`
+    4. Ações dentro do Iterator usam `{{iterator.currentItem.fieldName}}`
+  </Accordion>
+
+  <Accordion title="Qual é o tempo máximo de execução para ações Code?">
+    As ações Code (funções lógicas) têm um **tempo limite padrão de 5 minutos** (300 segundos).
+
+    O tempo limite máximo configurável é de **15 minutos** (900 segundos).
+
+    Se seu código exceder esse limite, a ação falhará com um erro de tempo limite.
+
+    **Dicas para evitar estouros de tempo**:
+    * Divida operações grandes em partes menores usando o Iterator
+    * Evite computações pesadas; use serviços externos via HTTP Request para processamento intensivo
+    * Otimize seu código para reduzir o tempo de execução
+    * Se você precisar de um processamento mais longo, considere usar fluxos de trabalho agendados que processem dados em lotes
+  </Accordion>
+
+  <Accordion title="Como leio as execuções de fluxo de trabalho?">
+    As execuções de fluxo de trabalho mostram o histórico de execução e ajudam você a depurar problemas.
+
+    **Acessar execuções**:
+    * No editor de fluxo de trabalho → painel **Execuções** à direita
+    * Ou vá para **Execuções de Fluxo de Trabalho** na barra lateral
+
+    **Entendendo uma execução**:
+    * **Status**: Em execução, Concluída, Falhou, Aguardando
+    * **Etapas**: Veja quais etapas foram executadas e suas saídas
+    * **Erros**: Clique nas etapas com falha para ver as mensagens de erro
+    * **Dados**: Veja os dados de entrada/saída em cada etapa
+
+    Veja [Execuções de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-runs) para obter detalhes.
+  </Accordion>
+
+  <Accordion title="Por que não vejo minhas execuções de fluxo de trabalho?">
+    As execuções de fluxo de trabalho podem estar falhando imediatamente devido a limites de taxa. Twenty impõe um limite rígido de 5.000 execuções por hora por espaço de trabalho.
+
+    Se você exceder esse limite, os fluxos de trabalho são marcados imediatamente como falhos e não aparecerão na sua lista de execuções.
+
+    **Cenários comuns que atingem esse limite**:
+    * Selecionar mais de 5.000 registros com um gatilho manual Single
+    * Vários fluxos de trabalho executando simultaneamente em todo o seu espaço de trabalho
+    * Gatilhos automatizados de alta frequência (por exemplo, Record Updated em um objeto movimentado)
+
+    **Soluções**:
+    * Use gatilhos **Bulk** em vez de Single para processar muitos registros em uma única execução
+    * Espaçe as operações em lotes grandes
+    * Use filtros para reduzir a frequência dos gatilhos
+    * Agende fluxos de trabalho pesados fora do horário de pico
+  </Accordion>
+
+  <Accordion title="Quais são os limites de taxa dos fluxos de trabalho?">
+    A Twenty tem dois limites de taxa para garantir a estabilidade do sistema:
+
+    | Limite | Valor | Comportamento |
+    | ------ | ----- | ------------- |
+    \| **Limite flexível** | 100 execuções/minuto | Execuções entram na fila com status "Not Started", processadas gradualmente |
+    \| **Limite rígido** | 5.000 execuções/hora | Execuções falham imediatamente |
+
+    **Limite flexível (100/min)**: Seus fluxos de trabalho não falharão — eles apenas aguardam na fila e são processados ao longo do tempo. Você pode acionar mais de 100 registros; a execução será mais lenta.
+
+    **Limite rígido (5.000/h)**: Isso se aplica a todo o seu espaço de trabalho. Se todos os seus fluxos de trabalho combinados excederem 5.000 execuções em uma hora, execuções adicionais falharão imediatamente.
+
+    **Dicas para permanecer dentro dos limites**:
+    * Use gatilhos Bulk com Iterator em vez de gatilhos Single para grandes lotes
+    * Combine automações relacionadas em menos fluxos de trabalho
+    * Use fluxos de trabalho agendados para distribuir a carga ao longo do tempo
+  </Accordion>
+
+  <Accordion title="Posso tentar novamente uma execução de fluxo de trabalho com falha?">
+    **Não, no momento não há funcionalidade de nova tentativa automática.**
+
+    Se uma execução de fluxo de trabalho falhar, você precisará:
+    1. Revise o erro em **Configurações → Fluxos de trabalho → [Seu Fluxo de Trabalho] → Execuções**
+    2. Corrija o problema (dados, configuração ou serviço externo)
+    3. Dispare manualmente o fluxo de trabalho novamente no(s) registro(s) afetado(s)
+
+    **Dicas para reduzir falhas**:
+    * Adicione nós **Filter** para validar dados antes das ações
+    * Use **Search Records** para verificar se existem registros relacionados
+    * Teste profundamente com alguns registros antes de operações em massa
+
+    A funcionalidade de nova tentativa automática está em nosso roadmap para uma versão futura.
+  </Accordion>
+
+  <Accordion title="Devo desativar fluxos de trabalho antes de importações CSV?">
+    **Sim, se seus fluxos de trabalho forem acionados por criação ou atualização de registros.**
+
+    Quando você importa dados via CSV, cada registro criado ou atualizado pode acionar fluxos de trabalho. Uma importação grande (milhares de registros) pode:
+    * Atingir o limite de 5.000 execuções/hora
+    * Consumir uma quantidade significativa de créditos de fluxo de trabalho
+    * Enviar e-mails ou notificações inesperadas
+    * Criar tarefas ou registros duplicados
+
+    **Antes de uma importação em massa**:
+    1. Vá para **Configurações → Fluxos de trabalho**
+    2. Identifique os fluxos de trabalho acionados pelo objeto que você está importando
+    3. **Desative**-os temporariamente
+    4. Execute sua importação CSV
+    5. **Reative** os fluxos de trabalho quando terminar
+
+    **Alternativa**: Se você precisar que os fluxos de trabalho sejam executados nos dados importados, importe em lotes menores para permanecer dentro dos limites de taxa.
+  </Accordion>
+
+  <Accordion title="Como organizar o layout do meu fluxo de trabalho?">
+    Se sua tela de fluxo de trabalho estiver desorganizada com nós espalhados, você pode organizá-la automaticamente:
+
+    1. Clique com o botão direito em qualquer lugar na tela do fluxo de trabalho
+    2. Clique em **Tidy up workflow**
+
+    Isso reorganizará automaticamente todos os nós em um layout limpo e organizado.
+  </Accordion>
+
+</AccordionGroup>

packages/twenty-docs/l/pt/user-guide/workflows/overview.mdx

@@ -0,0 +1,81 @@
+---
+title: Fluxos de trabalho
+description: Aprenda a criar automações no Twenty.
+---
+
+## Por que Workflows Importam
+
+Twenty foi criado para trazer flexibilidade máxima aos seus usuários. Em vez de forçá-lo a adaptar seus processos de negócios a recursos rígidos e pré-construídos, os workflows permitem que você crie automações que criem o CRM que melhor apoie seus casos de uso de negócios exclusivos.
+
+Workflows são o recurso interno de Twenty para criar essas automações. Eles oferecem os blocos de construção para criar exatamente o que seu negócio precisa, quando precisa.
+
+## O que posso fazer com workflows?
+
+Recomendamos a construção de automações para dois principais propósitos:
+
+1. **Automações internas para facilitar o dia a dia da sua equipe**: Reduza a quantidade de entradas manuais e tarefas repetitivas que retardam sua equipe.
+2. **Traga dados para dentro e para fora do Twenty**: Conecte-se ao Twenty por meio de chamadas de API e webhooks para seu banco de dados e outras ferramentas.
+
+## Criando seu primeiro fluxo de trabalho
+
+### Etapa 1: Criar um novo fluxo de trabalho
+
+1. Vá para **Workflows**, localizado abaixo dos outros objetos
+2. Clique em **+ New Record**
+3. Dê um nome ao seu fluxo de trabalho
+
+### Etapa 2: Adicionar um gatilho
+
+Todo fluxo de trabalho começa com um gatilho. Escolha entre:
+
+* **Eventos de registro**: Quando um registro é criado, atualizado ou excluído
+* **Agendamento**: Executar em horários específicos (diariamente, semanalmente, etc.)
+* **Manual**: Acionado por uma ação do usuário
+* **Webhook**: Acionado por um webhook
+
+<img src="/images/user-guide/workflows/workflow_triggers.png" style={{width:'100%'}} />
+
+### Etapa 3: Adicionar ações
+
+Após o gatilho, adicione uma ou mais ações:
+
+* **Criar registro**: Adicionar novos registros a qualquer objeto
+* **Atualizar registro**: Modificar os dados do registro existente
+* **Excluir registro**: Remover registros de objetos
+* **Pesquisar registros**: Encontrar registros que correspondam aos critérios
+* **Inserir/atualizar registro**: Criar ou atualizar com base em critérios de correspondência
+* **Iterador**: Percorrer arrays de registros
+* **Filtro**: Controlar quais registros prosseguem
+* **Atraso**: Aguardar antes de continuar (duração ou data agendada)
+* **Enviar e-mail**: Enviar e-mails via sua conta conectada
+* **Código**: Executar JavaScript personalizado
+* **Solicitação HTTP**: Chamar APIs externas
+* **Formulário**: Obter entradas de usuários na interface do Twenty no momento da execução
+* **Agente de IA** (Em breve): Executar tarefas de IA inteligentes
+
+<img src="/images/user-guide/workflows/workflow_actions.png" style={{width:'100%'}} />
+
+### Etapa 4: Testar e ativar
+
+1. Use o botão **Test** para executar seu fluxo de trabalho com dados de exemplo
+2. Revise os resultados para garantir que funcione como esperado
+3. Alterne o fluxo de trabalho para **Active** quando estiver pronto
+
+## Melhores Práticas de Workflows
+
+* **Editar nomes de etapas**: Renomeie as etapas do seu Workflow para descrever claramente o que cada uma faz. Isso ajuda na manutenção e facilita a transferência para colegas
+* **Aproveitar dados de etapas anteriores**: Você pode usar campos de registros retornados por qualquer etapa anterior no seu Workflow
+* **Comece simples**: Inicie com Workflows básicos e adicione complexidade ao longo do tempo à medida que se sentir mais confortável com o sistema
+* **Planeje antes de construir**: Mapeie a lógica do seu Workflow antes de começar a construir para evitar ficar preso no meio do caminho
+
+## Próximos Passos
+
+* [Gatilhos de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-triggers)
+* [Ações de Fluxo de Trabalho](/l/pt/user-guide/workflows/capabilities/workflow-actions)
+* [Automações de CRM](/l/pt/user-guide/workflows/how-tos/crm-automations/closed-won-automations)
+
+## Precisa de ajuda?
+
+<Tip>
+  Quer ajuda para automatizar seus fluxos de trabalho? [Encontre um Vinte Parceiro certificado](https://twenty.com/partners/list?categories=SOLUTIONING\&ref=docs-workflows) para projetar e construir suas automações de ponta a ponta.
+</Tip>