> ## Documentation Index
> Fetch the complete documentation index at: https://docs.jelou.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Condicional

> Direcione a conversa por caminhos diferentes com base nas respostas do usuário ou em dados

O nó **Condicional** funciona como um ponto de decisão dentro do seu fluxo: ele avalia informações que você já tem sobre o usuário e decide qual caminho seguir. Pense nele como uma bifurcação no caminho — dependendo do que o usuário responde ou dos dados que possui, a conversa seguirá uma rota ou outra.

## Conceito-chave: caminhos e regras

Antes de configurar, é importante entender dois conceitos:

* **Caminho**: uma rota que a conversa pode seguir. Cada caminho tem um nome descritivo e uma ou mais regras que devem ser atendidas para que ele seja ativado.
* **Regra**: uma condição individual que compara uma variável com um valor. Por exemplo: *"a idade do usuário é maior ou igual a 18"*.

<Note>
  Se um caminho tem **várias regras**, **todas** elas devem ser atendidas para que esse caminho seja ativado (lógica AND). Se você precisar que ele seja ativado quando **qualquer** uma das condições for atendida, crie **caminhos separados** para cada uma.
</Note>

### Caminho padrão: "Caso contrário"

Todo nó Condicional inclui automaticamente um caminho chamado **"Caso contrário"** (fallback). Este caminho é ativado quando **nenhum** dos outros caminhos é atendido. É a sua rede de segurança para garantir que a conversa sempre tenha um caminho a seguir.

***

## Configuração passo a passo

<Steps>
  <Step title="Criar um novo caminho">
    Clique em **"Novo caminho"** para adicionar sua primeira condição. Dê a ele um nome descritivo que ajude a identificar rapidamente o que ele avalia (por exemplo: "Adulto", "Cliente Premium", "Horário comercial").
  </Step>

  <Step title="Configurar a primeira regra">
    Cada regra tem três partes:

    1. **Variável** — os dados que você deseja avaliar (por exemplo, `{{$memory.age}}`)
    2. **Operador** — como você quer comparar esses dados (por exemplo, "Maior ou igual")
    3. **Valor** — o que você compara com (por exemplo, `18`)
  </Step>

  <Step title="Adicionar mais regras se necessário">
    Se você precisar que várias condições sejam atendidas ao mesmo tempo, clique em **"+"** dentro do mesmo caminho para adicionar regras adicionais. Todas as regras dentro de um caminho são avaliadas com lógica **AND** (todas devem ser verdadeiras).
  </Step>

  <Step title="Criar caminhos adicionais">
    Repita o processo para cada rota alternativa que você precisar. Cada caminho é avaliado em ordem: o primeiro que for atendido será o executado.
  </Step>

  <Step title="Conectar os nós seguintes">
    Cada caminho (incluindo "Caso contrário") tem um ponto de conexão à direita. Arraste uma linha de cada ponto para o nó que deve ser executado nessa rota.
  </Step>
</Steps>

***

## Operadores disponíveis

Os operadores definem **como** a variável é comparada ao valor. Eles são organizados em quatro categorias:

### Comparação de igualdade

| Operador      | Descrição                  | Exemplo                                       |
| :------------ | :------------------------- | :-------------------------------------------- |
| **Igual**     | O valor é exatamente igual | `{{$memory.status}}` igual a `active`         |
| **Diferente** | O valor é diferente        | `{{$memory.status}}` diferente de `cancelled` |

### Comparação numérica

| Operador           | Descrição                    | Exemplo                                   |
| :----------------- | :--------------------------- | :---------------------------------------- |
| **Maior que**      | O valor é estritamente maior | `{{$memory.age}}` maior que `18`          |
| **Maior ou igual** | O valor é maior ou igual     | `{{$memory.score}}` maior ou igual a `70` |
| **Menor que**      | O valor é estritamente menor | `{{$memory.attempts}}` menor que `3`      |
| **Menor ou igual** | O valor é menor ou igual     | `{{$memory.debt}}` menor ou igual a `0`   |

### Busca em texto

| Operador           | Descrição                             | Exemplo                                      |
| :----------------- | :------------------------------------ | :------------------------------------------- |
| **Contém**         | O texto inclui a palavra ou frase     | `{{$message.text}}` contém `ajuda`           |
| **Não contém**     | O texto não inclui a palavra ou frase | `{{$message.text}}` não contém `cancelar`    |
| **Começa com**     | O texto começa com o valor            | `{{$user.email}}` começa com `admin`         |
| **Não começa com** | O texto não começa com o valor        | `{{$user.phone}}` não começa com `+55`       |
| **Termina com**    | O texto termina com o valor           | `{{$user.email}}` termina com `@empresa.com` |

### Validação de tipo (É / Não é)

Os operadores **É** e **Não é** permitem verificar se uma variável corresponde a um tipo de dado específico. Em vez de inserir um valor, você seleciona o tipo de uma lista:

| Tipo             | O que valida                      |
| :--------------- | :-------------------------------- |
| **Alfanumérico** | Letras e números combinados       |
| **Alfabético**   | Somente letras                    |
| **Nome(s)**      | Formato de nome de pessoa         |
| **Número**       | Somente valores numéricos         |
| **E-mail**       | Formato de endereço de e-mail     |
| **Número de ID** | Número de documento de identidade |
| **URL**          | Formato de link web               |
| **Data**         | Formato de data                   |
| **Imagem**       | Arquivo de imagem                 |
| **CPF/CNPJ**     | Registro de contribuinte          |
| **Localização**  | Coordenadas ou endereço           |

**Exemplo**: `{{$memory.email}}` **É** → **E-mail** verifica se o que o usuário digitou tem formato de endereço de e-mail.

### Verificação de vazio

| Operador      | Descrição                          | Exemplo                           |
| :------------ | :--------------------------------- | :-------------------------------- |
| **Vazio**     | A variável não tem valor atribuído | `{{$memory.name}}` está vazio     |
| **Não vazio** | A variável tem algum valor         | `{{$memory.name}}` não está vazio |

<Note>
  Os operadores **Vazio** e **Não vazio** não exigem um valor de comparação — eles apenas avaliam se a variável tem conteúdo ou não.
</Note>

### Expressões regulares (Regex)

| Operador                  | Descrição                       | Exemplo                                          |
| :------------------------ | :------------------------------ | :----------------------------------------------- |
| **Regex corresponde**     | Corresponde ao padrão regex     | `{{$message.text}}` regex corresponde `^\d{10}$` |
| **Regex não corresponde** | Não corresponde ao padrão regex | `{{$message.text}}` regex não corresponde `[<>]` |

<Warning>
  Expressões regulares são uma ferramenta avançada. Se você não está familiarizado com regex, os outros operadores cobrem a maioria dos cenários comuns.
</Warning>

***

## Lógica de avaliação

O nó Condicional avalia os caminhos **de cima para baixo**, na ordem em que aparecem no painel. O primeiro caminho cujas regras forem atendidas será o executado.

```
O Caminho 1 é atendido?
  └─ Sim → Executar rota do Caminho 1
  └─ Não → O Caminho 2 é atendido?
            └─ Sim → Executar rota do Caminho 2
            └─ Não → O Caminho 3 é atendido?
                      └─ Sim → Executar rota do Caminho 3
                      └─ Não → Executar rota "Caso contrário" (fallback)
```

<Note>
  Você pode **reordenar os caminhos** arrastando-os com o ícone de mover (⠿) que aparece à esquerda de cada caminho. Isso é importante porque a ordem afeta qual é avaliado primeiro.
</Note>

### Lógica AND vs OR

| O que você precisa                          | Como configurar                                     |
| :------------------------------------------ | :-------------------------------------------------- |
| Todas as condições atendidas ao mesmo tempo | Adicionar várias regras **dentro do mesmo caminho** |
| Qualquer uma das condições atendida         | Criar **caminhos separados**, um para cada condição |

***

## Modos de visualização

O painel de configuração oferece dois modos de exibição que você pode alternar com o botão de visualização no canto superior:

* **Visualização expandida**: mostra cada regra como um cartão com rótulos descritivos (Variável, Operador, Valor). Ideal quando você está configurando condições pela primeira vez.
* **Visualização compacta**: mostra cada regra em uma única linha horizontal. Ideal quando você já conhece as condições e quer uma visão geral mais rápida.

***

## Exemplos práticos

### Verificação de idade

Um fluxo que precisa verificar se o usuário é maior de idade:

| Caminho            | Regra | Variável          | Operador       | Valor |
| :----------------- | :---- | :---------------- | :------------- | :---- |
| Adulto             | 1     | `{{$memory.age}}` | Maior ou igual | `18`  |
| **Caso contrário** | —     | —                 | —              | —     |

O caminho "Adulto" é ativado se a idade for 18 ou mais. Qualquer outro caso continua por "Caso contrário".

### Roteamento por país e tipo de cliente

Um fluxo que direciona clientes premium da Colômbia para um fluxo especial:

| Caminho            | Regra | Variável                    | Operador | Valor      |
| :----------------- | :---- | :-------------------------- | :------- | :--------- |
| Premium Colômbia   | 1     | `{{$user.country}}`         | Igual    | `Colombia` |
|                    | 2     | `{{$memory.customer_type}}` | Igual    | `premium`  |
| Regular Colômbia   | 1     | `{{$user.country}}`         | Igual    | `Colombia` |
| **Caso contrário** | —     | —                           | —        | —          |

Em "Premium Colômbia", **ambas** as regras devem ser atendidas (AND): o país deve ser Colômbia **e** o tipo de cliente deve ser premium. Se apenas a primeira for atendida, o fluxo passa para avaliar "Regular Colômbia".

### Validação de formato de entrada

Um fluxo que valida se o usuário digitou um endereço de e-mail:

| Caminho            | Regra | Variável            | Operador | Tipo   |
| :----------------- | :---- | :------------------ | :------- | :----- |
| E-mail válido      | 1     | `{{$memory.email}}` | É        | E-mail |
| **Caso contrário** | —     | —                   | —        | —      |

Se os dados tiverem formato de e-mail, continua por "E-mail válido". Caso contrário, você pode usar o caminho "Caso contrário" para pedir ao usuário que insira novamente.

### Detecção de intenção a partir do texto

Um fluxo que detecta palavras-chave na mensagem do usuário:

| Caminho            | Regra | Variável            | Operador | Valor      |
| :----------------- | :---- | :------------------ | :------- | :--------- |
| Quer cancelar      | 1     | `{{$message.text}}` | Contém   | `cancelar` |
| Quer ajuda         | 1     | `{{$message.text}}` | Contém   | `ajuda`    |
| Saudação           | 1     | `{{$message.text}}` | Contém   | `olá`      |
| **Caso contrário** | —     | —                   | —        | —          |

Cada caminho é independente (lógica OR): se a mensagem contém "cancelar", segue a primeira rota; se contém "ajuda", a segunda, e assim por diante.