diff --git a/docs/en/filter.md b/docs/en/filter.md
new file mode 100644
index 00000000..6bad81a2
--- /dev/null
+++ b/docs/en/filter.md
@@ -0,0 +1,493 @@
+# Konecty Filters
+
+This guide was developed to help you quickly and efficiently start creating filters in Konecty.
+
+## What are Filters?
+
+Filters in Konecty are structures that allow you to search and filter data according to specific criteria. They are used in various parts of the system, such as:
+- Lists
+- Reports
+- Automations
+- Business Rules
+
+## Basic Structure
+
+Every filter in Konecty follows this basic structure:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "field",
+            "value": "value"
+        }
+    ]
+}
+```
+
+Where:
+- `match`: Defines how multiple conditions relate ("and" or "or")
+- `conditions`: List of filter conditions
+- Each condition has:
+  - `operator`: The type of comparison
+  - `term`: The field to be compared
+  - `value`: The value for comparison
+
+## Nested Filters
+
+Konecty supports nested filters, allowing you to create more complex logic by combining multiple filters:
+
+```json
+{
+    "match": "or",           // Logical operator between filters: "or" or "and"
+    "filters": [             // Array of sub-filters
+        {
+            "match": "and",  // Logical operator between conditions
+            "conditions": [   // Array of conditions
+                {
+                    "term": "status",    // Field to filter
+                    "value": [           // Value or array of values
+                        "New",
+                        "In+Progress"
+                    ],
+                    "operator": "in"     // Comparison operator
+                }
+            ]
+        },
+        {
+            "match": "and",
+            "conditions": [
+                {
+                    "term": "_user._id", // Nested fields using dot notation
+                    "value": "$user",    // Special values start with $
+                    "operator": "equals"
+                }
+            ]
+        }
+    ]
+}
+```
+
+### Nested Filters Characteristics
+
+1. **Nesting Levels**
+   - You can nest filters in multiple levels
+   - Each level can have its own logical operator (`match`)
+   - There is no theoretical limit to the number of levels
+
+2. **Combining Conditions**
+   - Use `match: "and"` when all conditions must be true
+   - Use `match: "or"` when any condition can be true
+   - Mix `and` and `or` at different levels for complex logic
+
+3. **Structure**
+   - `filters`: Array of sub-filters
+   - Each sub-filter can contain:
+     - `match`: Logical operator
+     - `conditions`: Direct conditions
+     - `filters`: More sub-filters
+
+### Practical Nested Filter Example
+
+Search for opportunities that:
+- Are new or in progress
+- And belong to the current user
+- Or have value greater than 10000
+
+```json
+{
+    "match": "or",
+    "filters": [
+        {
+            "match": "and",
+            "conditions": [
+                {
+                    "term": "status",
+                    "value": ["New", "In+Progress"],
+                    "operator": "in"
+                },
+                {
+                    "term": "_user._id",
+                    "value": "$user",
+                    "operator": "equals"
+                }
+            ]
+        },
+        {
+            "match": "and",
+            "conditions": [
+                {
+                    "term": "value.value",
+                    "value": 10000,
+                    "operator": "greater_than"
+                }
+            ]
+        }
+    ]
+}
+```
+
+## First Steps
+
+### 1. Simple Filter
+Let's start with a simple filter that searches for active contacts:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "status",
+            "value": "Active"
+        }
+    ]
+}
+```
+
+### 2. Combining Conditions
+Now, let's search for active contacts from the state of California:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "status",
+            "value": "Active"
+        },
+        {
+            "operator": "equals",
+            "term": "address.state",
+            "value": "CA"
+        }
+    ]
+}
+```
+
+### 3. Using OR
+Search for contacts from California OR New York:
+
+```json
+{
+    "match": "or",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "address.state",
+            "value": "CA"
+        },
+        {
+            "operator": "equals",
+            "term": "address.state",
+            "value": "NY"
+        }
+    ]
+}
+```
+
+## Common Operators
+
+### Equality
+```json
+{
+    "operator": "equals",
+    "term": "name",
+    "value": "John Smith"
+}
+```
+
+### Contains Text
+```json
+{
+    "operator": "contains",
+    "term": "name",
+    "value": "Smith"
+}
+```
+
+### Greater/Less Than
+```json
+{
+    "operator": "greater_than",
+    "term": "age",
+    "value": 18
+}
+```
+
+### List of Values
+```json
+{
+    "operator": "in",
+    "term": "status",
+    "value": ["Active", "Pending", "Under Review"]
+}
+```
+
+## Practical Examples
+
+### 1. Search Recent Opportunities
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "greater_than",
+            "term": "createdAt",
+            "value": {
+                "$date": "2024-01-01T00:00:00.000Z"
+            }
+        },
+        {
+            "operator": "in",
+            "term": "status",
+            "value": ["New", "In Progress"]
+        }
+    ]
+}
+```
+
+### 2. Filter Contacts by Phone and Email
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "exists",
+            "term": "email",
+            "value": true
+        },
+        {
+            "operator": "starts_with",
+            "term": "phone.phoneNumber",
+            "value": "1"
+        }
+    ]
+}
+```
+
+### 3. Search by Owner
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "_user._id",
+            "value": "$user"
+        }
+    ]
+}
+```
+
+## Tips and Tricks
+
+### Special Values
+- Use `$user` to reference the current user
+- Use `$now` for the current date
+- Use `$group` for the current user's group
+- Use `$groups` for the current user's secondary groups
+- Use `$allgroups` for all user's groups (main and secondary)
+
+### Nested Fields
+To access fields within objects, use dots:
+- `address.city`
+- `contact.name.first`
+- `opportunity.value.currency`
+
+### Date Filters
+Always use ISO format for dates:
+```json
+{
+    "operator": "equals",
+    "term": "birthDate",
+    "value": {
+        "$date": "1990-01-01T00:00:00.000Z"
+    }
+}
+```
+
+### Special Variables ($)
+
+Konecty provides special variables that can be used in filters for dynamic references:
+
+- **`$user`**: Current user ID
+  ```json
+  {
+      "operator": "equals",
+      "term": "owner._id",
+      "value": "$user"
+  }
+  ```
+
+- **`$group`**: Current user's main group ID
+  ```json
+  {
+      "operator": "equals",
+      "term": "group._id",
+      "value": "$group"
+  }
+  ```
+
+- **`$groups`**: Array of current user's secondary group IDs
+  ```json
+  {
+      "operator": "in",
+      "term": "groups._id",
+      "value": "$groups"
+  }
+  ```
+
+- **`$allgroups`**: Array of all user's groups (main and secondary)
+  ```json
+  {
+      "operator": "in",
+      "term": "groups._id",
+      "value": "$allgroups"
+  }
+  ```
+
+- **`$now`**: Current date and time
+  ```json
+  {
+      "operator": "less_than",
+      "term": "dueDate",
+      "value": "$now"
+  }
+  ```
+
+- **`$user.field`**: Access to specific fields of the current user
+  ```json
+  {
+      "operator": "equals",
+      "term": "branch._id",
+      "value": "$user.branch._id"
+  }
+  ```
+
+#### Example Combining Special Variables
+
+Search for records that belong to the current user's group and were created today:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "group._id",
+            "value": "$group"
+        },
+        {
+            "operator": "greater_or_equals",
+            "term": "_createdAt",
+            "value": "$now"
+        }
+    ]
+}
+```
+
+## Common Issues
+
+### 1. Incorrect Date Format
+❌ Wrong:
+```json
+{
+    "value": "2024-01-01"
+}
+```
+
+✅ Correct:
+```json
+{
+    "value": {
+        "$date": "2024-01-01T00:00:00.000Z"
+    }
+}
+```
+
+### 2. Invalid Operator for Type
+❌ Wrong:
+```json
+{
+    "operator": "contains",
+    "term": "age",
+    "value": "2"
+}
+```
+
+✅ Correct:
+```json
+{
+    "operator": "equals",
+    "term": "age",
+    "value": 2
+}
+```
+
+### 3. Non-existent Field
+❌ Wrong:
+```json
+{
+    "term": "direccion.ciudad"
+}
+```
+
+✅ Correct:
+```json
+{
+    "term": "address.city"
+}
+```
+
+## Next Steps
+
+1. Start with simple filters and gradually increase complexity
+2. Use the browser console to test filters
+3. Check the complete documentation for specific cases
+4. Practice combining different operators
+
+## Quick References
+
+### Operators by Field Type
+
+#### Text
+- `equals`
+- `not_equals`
+- `contains`
+- `starts_with`
+- `end_with`
+
+#### Numbers
+- `equals`
+- `greater_than`
+- `less_than`
+- `between`
+
+#### Dates
+- `equals`
+- `greater_than`
+- `less_than`
+- `between`
+
+#### Booleans
+- `equals`
+- `not_equals`
+
+#### Lists
+- `in`
+- `not_in`
+
+### Common Fields
+- `_id`: Record ID
+- `_createdAt`: Creation date
+- `_updatedAt`: Update date
+- `_user`: Owner user
+- `status`: Record status
+- `name`: Name
+- `email`: Email
+- `phone`: Phone
+``` 
\ No newline at end of file
diff --git a/docs/pt-BR/dados.md b/docs/pt-BR/dados.md
new file mode 100644
index 00000000..f360feb6
--- /dev/null
+++ b/docs/pt-BR/dados.md
@@ -0,0 +1,185 @@
+# Documentação das Funções
+
+## `update`
+
+### Utilidade
+Atualiza registros em um documento específico no banco de dados.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento a ser atualizado.
+- `data` (object): Dados a serem atualizados, incluindo uma lista de IDs e os campos a serem atualizados.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+- `tracingSpan` (object, opcional): Span de rastreamento para telemetria.
+
+### Regras Principais
+- Verifica permissões de acesso e atualização.
+- Valida os dados e os IDs fornecidos.
+- Executa scripts de validação antes e depois da atualização.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `getNextUserFromQueue`
+
+### Utilidade
+Obtém o próximo usuário da fila para um documento específico.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `queueId` (string): ID da fila.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+
+### Regras Principais
+- Verifica permissões de acesso.
+- Retorna um erro se o usuário não tiver permissão.
+
+## `find`
+
+### Utilidade
+Busca registros em um documento específico com base em filtros e critérios de ordenação.
+
+### Parâmetros
+- `authTokenId` (string, opcional): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `filter` (string | object): Filtro para a busca.
+- `fields` (string, opcional): Campos a serem retornados.
+- `sort` (string, opcional): Critérios de ordenação.
+- `limit` (number, opcional): Limite de registros retornados (padrão: 50).
+- `start` (number, opcional): Índice inicial (padrão: 0).
+- `getTotal` (boolean, opcional): Se deve retornar o total de registros.
+- `withDetailFields` (boolean, opcional): Se deve incluir campos detalhados.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+- `transformDatesToString` (boolean, opcional): Se deve transformar datas em strings (padrão: true).
+- `tracingSpan` (object, opcional): Span de rastreamento para telemetria.
+
+### Regras Principais
+- Verifica permissões de leitura.
+- Aplica filtros e critérios de ordenação.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `saveLead`
+
+### Utilidade
+Salva uma lead com os dados fornecidos, atualizando se a lead já existir.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `lead` (object): Dados da lead.
+- `save` (array, opcional): Relações a serem salvas.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+
+### Regras Principais
+- Verifica permissões de acesso.
+- Valida a presença de email ou telefone.
+- Busca contato existente e atualiza dados conforme necessário.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `findById`
+
+### Utilidade
+Busca um registro específico por ID em um documento.
+
+### Parâmetros
+- `authTokenId` (string, opcional): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `fields` (string, opcional): Campos a serem retornados.
+- `dataId` (string): ID do registro.
+- `withDetailFields` (boolean, opcional): Se deve incluir campos detalhados.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+
+### Regras Principais
+- Verifica permissões de leitura.
+- Valida o ID do registro.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `deleteData`
+
+### Utilidade
+Deleta registros em um documento específico.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `data` (object): Dados contendo IDs dos registros a serem deletados.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+
+### Regras Principais
+- Verifica permissões de exclusão.
+- Valida os IDs dos registros.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `create`
+
+### Utilidade
+Cria um novo registro em um documento específico.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `data` (object): Dados do novo registro.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+- `upsert` (boolean, opcional): Se deve fazer upsert.
+- `updateOnUpsert` (boolean, opcional): Se deve atualizar no upsert.
+- `ignoreAutoNumber` (boolean, opcional): Se deve ignorar auto-numeração.
+- `tracingSpan` (object, opcional): Span de rastreamento para telemetria.
+
+### Regras Principais
+- Verifica permissões de criação.
+- Valida os dados fornecidos.
+- Executa scripts de validação antes e depois da criação.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `historyFind`
+
+### Utilidade
+Busca o histórico de um registro específico por ID em um documento.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `dataId` (string): ID do registro.
+- `fields` (string, opcional): Campos a serem retornados.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+
+### Regras Principais
+- Verifica permissões de leitura.
+- Valida o ID do registro.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `relationCreate`
+
+### Utilidade
+Cria uma relação para um campo específico em um documento.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `fieldName` (string): Nome do campo de relação.
+- `data` (object): Dados da relação.
+- `preview` (boolean, opcional): Se deve fazer um preview da relação.
+- `contextUser` (object, opcional): Usuário no contexto da operação.
+
+### Regras Principais
+- Verifica permissões de acesso.
+- Valida os dados e a relação fornecidos.
+- Retorna um erro se os dados ou permissões forem inválidos.
+
+## `findByLookup`
+
+### Utilidade
+Busca registros em um documento específico com base em um campo de lookup.
+
+### Parâmetros
+- `authTokenId` (string): ID do token de autenticação.
+- `document` (string): Nome do documento.
+- `fieldName` (string): Nome do campo de lookup.
+- `search` (string): Termo de busca.
+- `extraFilter` (object, opcional): Filtro adicional.
+- `start` (number, opcional): Índice inicial.
+- `limit` (number, opcional): Limite de registros retornados.
+- `useChangeUserFilter` (boolean, opcional): Se deve usar o filtro de mudança de usuário.
+
+### Regras Principais
+- Verifica permissões de leitura.
+- Aplica filtros e critérios de busca.
+- Retorna um erro se os dados ou permissões forem inválidos.
diff --git a/docs/pt-BR/filtros.md b/docs/pt-BR/filtros.md
new file mode 100644
index 00000000..7915c828
--- /dev/null
+++ b/docs/pt-BR/filtros.md
@@ -0,0 +1,493 @@
+# Filtros no Konecty
+
+Este guia foi desenvolvido para ajudar você a começar a criar filtros no Konecty de forma rápida e eficiente.
+
+## O que são Filtros?
+
+Filtros no Konecty são estruturas que permitem buscar e filtrar dados de acordo com critérios específicos. Eles são usados em várias partes do sistema, como:
+- Listagens
+- Relatórios
+- Automações
+- Regras de negócio
+
+## Estrutura Básica
+
+Todo filtro no Konecty segue esta estrutura básica:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "campo",
+            "value": "valor"
+        }
+    ]
+}
+```
+
+Onde:
+- `match`: Define como múltiplas condições se relacionam ("and" ou "or")
+- `conditions`: Lista de condições do filtro
+- Cada condição tem:
+  - `operator`: O tipo de comparação
+  - `term`: O campo a ser comparado
+  - `value`: O valor para comparação
+
+## Filtros Aninhados
+
+O Konecty suporta filtros aninhados, permitindo criar lógicas mais complexas combinando múltiplos filtros:
+
+```json
+{
+    "match": "or",           // Operador lógico entre os filtros: "or" ou "and"
+    "filters": [             // Array de sub-filtros
+        {
+            "match": "and",  // Operador lógico entre as condições
+            "conditions": [   // Array de condições
+                {
+                    "term": "status",    // Campo a ser filtrado
+                    "value": [           // Valor ou array de valores
+                        "Nova",
+                        "Em+Andamento"
+                    ],
+                    "operator": "in"     // Operador de comparação
+                }
+            ]
+        },
+        {
+            "match": "and",
+            "conditions": [
+                {
+                    "term": "_user._id", // Campos aninhados usando ponto
+                    "value": "$user",    // Valores especiais começam com $
+                    "operator": "equals"
+                }
+            ]
+        }
+    ]
+}
+```
+
+### Características dos Filtros Aninhados
+
+1. **Níveis de Aninhamento**
+   - Você pode aninhar filtros em múltiplos níveis
+   - Cada nível pode ter seu próprio operador lógico (`match`)
+   - Não há limite teórico para o número de níveis
+
+2. **Combinação de Condições**
+   - Use `match: "and"` quando todas as condições devem ser verdadeiras
+   - Use `match: "or"` quando qualquer condição pode ser verdadeira
+   - Misture `and` e `or` em diferentes níveis para lógicas complexas
+
+3. **Estrutura**
+   - `filters`: Array de sub-filtros
+   - Cada sub-filtro pode conter:
+     - `match`: Operador lógico
+     - `conditions`: Condições diretas
+     - `filters`: Mais sub-filtros
+
+### Exemplo Prático de Filtro Aninhado
+
+Buscar oportunidades que:
+- São novas ou em andamento
+- E pertencem ao usuário atual
+- Ou têm valor maior que 10000
+
+```json
+{
+    "match": "or",
+    "filters": [
+        {
+            "match": "and",
+            "conditions": [
+                {
+                    "term": "status",
+                    "value": ["Nova", "Em+Andamento"],
+                    "operator": "in"
+                },
+                {
+                    "term": "_user._id",
+                    "value": "$user",
+                    "operator": "equals"
+                }
+            ]
+        },
+        {
+            "match": "and",
+            "conditions": [
+                {
+                    "term": "value.value",
+                    "value": 10000,
+                    "operator": "greater_than"
+                }
+            ]
+        }
+    ]
+}
+```
+
+## Primeiros Passos
+
+### 1. Filtro Simples
+Vamos começar com um filtro simples que busca contatos ativos:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "status",
+            "value": "Ativo"
+        }
+    ]
+}
+```
+
+### 2. Combinando Condições
+Agora, vamos buscar contatos ativos que são do estado de São Paulo:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "status",
+            "value": "Ativo"
+        },
+        {
+            "operator": "equals",
+            "term": "address.state",
+            "value": "SP"
+        }
+    ]
+}
+```
+
+### 3. Usando OR
+Buscar contatos que são do Rio de Janeiro OU São Paulo:
+
+```json
+{
+    "match": "or",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "address.state",
+            "value": "SP"
+        },
+        {
+            "operator": "equals",
+            "term": "address.state",
+            "value": "RJ"
+        }
+    ]
+}
+```
+
+## Operadores Comuns
+
+### Igualdade
+```json
+{
+    "operator": "equals",
+    "term": "name",
+    "value": "João Silva"
+}
+```
+
+### Contém Texto
+```json
+{
+    "operator": "contains",
+    "term": "name",
+    "value": "Silva"
+}
+```
+
+### Maior/Menor que
+```json
+{
+    "operator": "greater_than",
+    "term": "age",
+    "value": 18
+}
+```
+
+### Lista de Valores
+```json
+{
+    "operator": "in",
+    "term": "status",
+    "value": ["Ativo", "Pendente", "Em Análise"]
+}
+```
+
+## Exemplos Práticos
+
+### 1. Buscar Oportunidades Recentes
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "greater_than",
+            "term": "createdAt",
+            "value": {
+                "$date": "2024-01-01T00:00:00.000Z"
+            }
+        },
+        {
+            "operator": "in",
+            "term": "status",
+            "value": ["Nova", "Em Andamento"]
+        }
+    ]
+}
+```
+
+### 2. Filtrar Contatos por Telefone e Email
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "exists",
+            "term": "email",
+            "value": true
+        },
+        {
+            "operator": "starts_with",
+            "term": "phone.phoneNumber",
+            "value": "11"
+        }
+    ]
+}
+```
+
+### 3. Buscar por Responsável
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "_user._id",
+            "value": "$user"
+        }
+    ]
+}
+```
+
+## Dicas e Truques
+
+### Valores Especiais
+- Use `$user` para referenciar o usuário atual
+- Use `$now` para a data atual
+- Use `$group` para o grupo do usuário atual
+- Use `$groups` para os grupos do usuário atual
+- Use `$allgroups` para todos os grupos do usuário atual
+
+### Campos Aninhados
+Para acessar campos dentro de objetos, use ponto:
+- `address.city`
+- `contact.name.first`
+- `opportunity.value.currency`
+
+### Filtros de Data
+Sempre use o formato ISO para datas:
+```json
+{
+    "operator": "equals",
+    "term": "birthDate",
+    "value": {
+        "$date": "1990-01-01T00:00:00.000Z"
+    }
+}
+```
+
+## Problemas Comuns
+
+### 1. Formato de Data Incorreto
+❌ Errado:
+```json
+{
+    "value": "2024-01-01"
+}
+```
+
+✅ Correto:
+```json
+{
+    "value": {
+        "$date": "2024-01-01T00:00:00.000Z"
+    }
+}
+```
+
+### 2. Operador Inválido para o Tipo
+❌ Errado:
+```json
+{
+    "operator": "contains",
+    "term": "age",
+    "value": "2"
+}
+```
+
+✅ Correto:
+```json
+{
+    "operator": "equals",
+    "term": "age",
+    "value": 2
+}
+```
+
+### 3. Campo Inexistente
+❌ Errado:
+```json
+{
+    "term": "endereco.cidade"
+}
+```
+
+✅ Correto:
+```json
+{
+    "term": "address.city"
+}
+```
+
+## Próximos Passos
+
+1. Experimente criar filtros simples e vá aumentando a complexidade
+2. Use o console do navegador para testar os filtros
+3. Verifique a documentação completa para casos específicos
+4. Pratique combinando diferentes operadores
+
+## Referências Rápidas
+
+### Operadores por Tipo de Campo
+
+#### Texto
+- `equals`
+- `not_equals`
+- `contains`
+- `starts_with`
+- `end_with`
+
+#### Números
+- `equals`
+- `greater_than`
+- `less_than`
+- `between`
+
+#### Datas
+- `equals`
+- `greater_than`
+- `less_than`
+- `between`
+
+#### Booleanos
+- `equals`
+- `not_equals`
+
+#### Listas
+- `in`
+- `not_in`
+
+### Campos Comuns
+- `_id`: ID do registro
+- `_createdAt`: Data de criação
+- `_updatedAt`: Data de atualização
+- `_user`: Usuário responsável
+- `status`: Status do registro
+- `name`: Nome
+- `email`: Email
+- `phone`: Telefone
+
+### Variáveis Especiais ($)
+
+O Konecty oferece variáveis especiais que podem ser usadas nos filtros para referências dinâmicas:
+
+- **`$user`**: ID do usuário atual
+  ```json
+  {
+      "operator": "equals",
+      "term": "responsavel._id",
+      "value": "$user"
+  }
+  ```
+
+- **`$group`**: ID do grupo principal do usuário atual
+  ```json
+  {
+      "operator": "equals",
+      "term": "grupo._id",
+      "value": "$group"
+  }
+  ```
+
+- **`$groups`**: Array com IDs dos grupos secundários do usuário atual
+  ```json
+  {
+      "operator": "in",
+      "term": "grupos._id",
+      "value": "$groups"
+  }
+  ```
+
+- **`$allgroups`**: Array com todos os grupos (principal e secundários) do usuário atual
+  ```json
+  {
+      "operator": "in",
+      "term": "grupos._id",
+      "value": "$allgroups"
+  }
+  ```
+
+- **`$now`**: Data e hora atual
+  ```json
+  {
+      "operator": "less_than",
+      "term": "dataVencimento",
+      "value": "$now"
+  }
+  ```
+
+- **`$user.campo`**: Acesso a campos específicos do usuário atual
+  ```json
+  {
+      "operator": "equals",
+      "term": "filial._id",
+      "value": "$user.filial._id"
+  }
+  ```
+
+#### Exemplo Combinando Variáveis Especiais
+
+Buscar registros que pertencem ao grupo do usuário atual e foram criados hoje:
+
+```json
+{
+    "match": "and",
+    "conditions": [
+        {
+            "operator": "equals",
+            "term": "grupo._id",
+            "value": "$group"
+        },
+        {
+            "operator": "greater_or_equals",
+            "term": "_createdAt",
+            "value": "$now"
+        }
+    ]
+}
+```
+``` 
\ No newline at end of file