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)