@intlayer/docs 8.12.4 → 9.0.0-canary.10

package/docs/pt/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-05-12
+updatedAt: 2026-06-17
 title: Configuração (Configuration)
 description: Saiba como configurar o Intlayer para a sua aplicação. Entenda as várias configurações e opções disponíveis para personalizar o Intlayer conforme as suas necessidades.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 8.10.0
+    date: 2026-06-17
+    changes: "Adicionada a opção `format` à configuração do dicionário"
   - version: 8.9.4
     date: 2026-05-12
     changes: "Adicionar suporte para o provedor LM Studio"
@@ -98,6 +101,7 @@ history:
   - version: 5.5.11
     date: 2025-06-29
     changes: "Adicionados os comandos `docs`"
+author: aymericzip
 ---
 
 # Documentação de Configuração do Intlayer
@@ -134,6 +138,7 @@ O Intlayer aceita os formatos de ficheiro de configuração JSON, JS, MJS e TS:
 ````typescript fileName="intlayer.config.ts" codeFormat="typescript"
 import { Locales, type IntlayerConfig } from "intlayer";
 import { nextjsRewrite } from "intlayer/routing";
+import { syncJSON } from "@intlayer/sync-json-plugin";
 import { z } from "zod";
 
 /**
@@ -584,10 +589,38 @@ const config: IntlayerConfig = {
     }),
   },
 
+  /**
+   * Configuração do dicionário.
+   */
+  dictionary: {
+    /**
+     * Controla como os dicionários são importados.
+     * - "static": Importado estaticamente no momento da build.
+     * - "dynamic": Importado dinamicamente usando Suspense.
+     * - "fetch": Buscado dinamicamente via API de sincronização ao vivo.
+     */
+    importMode: "static",
+
+    /**
+     * O formato de mensagem padrão para todos os dicionários no projeto.
+     * - 'intlayer': Formato nativo do intlayer (padrão).
+     * - 'icu': Formato de mensagem ICU.
+     * - 'i18next': Formato i18next.
+     * - 'vue-i18n': Formato Vue I18n.
+     * - 'po': Formato GNU Gettext PO.
+     */
+    format: "icu",
+  },
+
   /**
    * Configuração de plugins.
    */
-  plugins: [],
+  plugins: [
+    syncJSON({
+      format: "icu",
+      source: ({ locale }) => `./messages/${locale}.json`,
+    }),
+  ],
 };
 
 export default config;
@@ -644,7 +677,7 @@ Definições que controlam o comportamento do roteamento, incluindo estrutura de
 | `mode`     | Modo de roteamento de URL para a gestão de idiomas.                                                                                                                                                                     | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) ou `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: idioma gerido por outros meios. `'search-params'`: `/dashboard?locale=fr` | Não afeta a gestão de cookies ou armazenamento de idiomas.                                                                                                                                                                                                                                              |
 | `storage`  | Configuração para o armazenamento do idioma no cliente.                                                                                                                                                                 | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                          | Veja a tabela de Opções de Armazenamento abaixo.                                                                                                                                                                                                                                                        |
 | `basePath` | O caminho base para os URLs da aplicação.                                                                                                                                                                               | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                 | Se a app está em `https://example.com/my-app`, basePath é `'/my-app'` e os URLs tornam-se `https://example.com/my-app/en`.                                                                                                                                                                              |
-| `rewrite`  | Regras de reescrita de URL personalizadas que anulam o modo de roteamento padrão para caminhos específicos. Suporta parâmetros dinâmicos `[param]`.                                                                     | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Veja o exemplo abaixo                                                                                                                                                                       | • Regras de reescrita têm precedência sobre `mode`.<br/>• Funciona com Next.js e Vite.<br/>• `getLocalizedUrl()` aplica as regras correspondentes automaticamente.<br/>• Veja [Reescritas de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/custom_url_rewrites.md). |
+| `rewrite`  | Regras de reescrita de URL personalizadas que anulam o modo de roteamento padrão para caminhos específicos. Suporta parâmetros dinâmicos `[param]`.                                                                     | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Veja o exemplo abaixo                                                                                                                                                                       | • Regras de reescrita têm precedência sobre `mode`.<br/>• Funciona com Next.js e Vite.<br/>• `getLocalizedUrl()` aplica as regras correspondentes automaticamente.<br/>• Veja [Reescritas de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/custom_url_rewrites.md). |
 | `domains`  | Mapeia idiomas para nomes de host de domínio para roteamento baseado em domínio. Quando definido, as URLs para um idioma usam esse domínio como base (URL absoluta) e nenhum prefixo de idioma é adicionado ao caminho. | `Partial<Record<Locale, string>>`                                                                                                                                                                            | `undefined`            | `{ zh: 'intlayer.zh', fr: 'intlayer.org' }`                                                                                                                                                 | • O protocolo padrão é `https://` quando não incluído no nome do host.<br/>• O próprio domínio identifica o idioma, portanto nenhum prefixo `/zh/` é adicionado.<br/>• `getLocalizedUrl('/', 'zh')` retorna `https://intlayer.zh/`.                                                                     |
 
 **Exemplo de `rewrite`**:
@@ -852,24 +885,40 @@ Definições relacionadas à forma como o conteúdo é gerido dentro da aplicaç
 
 ---
 
+### Configuração do Sistema
+
+Configurações relacionadas a caminhos internos e resultados de saída do Intlayer. Essas configurações são tipicamente internas e não devem precisar ser modificadas pelo usuário.
+
+| Campo                     | Descrição                                                                                      | Tipo     | Padrão                            | Exemplo              | Nota                                                              |
+| ------------------------- | ---------------------------------------------------------------------------------------------- | -------- | --------------------------------- | -------------------- | ----------------------------------------------------------------- |
+| `baseDir`                 | O diretório base para o projeto.                                                               | `string` | `process.cwd()`                   | `'/path/to/project'` | Usado para resolver todos os diretórios relacionados ao Intlayer. |
+| `dictionariesDir`         | O caminho do diretório para armazenar dicionários de localização.                              | `string` | `'.intlayer/dictionary'`          |                      |                                                                   |
+| `moduleAugmentationDir`   | Diretório para aumento de módulo, permitindo melhores sugestões de IDE e verificação de tipos. | `string` | `'.intlayer/types'`               | `'intlayer-types'`   | Certifique-se de incluir isso em `tsconfig.json`.                 |
+| `unmergedDictionariesDir` | O diretório para armazenar dicionários não mesclados.                                          | `string` | `'.intlayer/unmerged_dictionary'` |                      |                                                                   |
+| `typesDir`                | O diretório para armazenar tipos de dicionário.                                                | `string` | `'.intlayer/types'`               |                      |                                                                   |
+| `mainDir`                 | O diretório onde os arquivos principais da aplicação são armazenados.                          | `string` | `'.intlayer/main'`                |                      |                                                                   |
+| `configDir`               | O diretório onde os arquivos de configuração são armazenados.                                  | `string` | `'.intlayer/config'`              |                      |                                                                   |
+| `cacheDir`                | O diretório onde os arquivos de cache são armazenados.                                         | `string` | `'.intlayer/cache'`               |                      |                                                                   |
+
 ### Configuração do Dicionário
 
 Parâmetros que controlam as operações do dicionário, incluindo o comportamento de preenchimento automático (auto-fill) e geração de conteúdo.
 
-| Campo                       | Descrição                                                                                                                                              | Tipo                                                                                                            | Padrão      | Exemplo                                                                                     | Nota                                                                                                                                                                                                                                                                                                                                                                                                    |
-| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- | ----------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `fill`                      | Controla como os ficheiros de saída do preenchimento automático (tradução por IA) são gerados.                                                         | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`      | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: caminho padrão (mesmo ficheiro que a origem).<br/>• `false`: desativar.<br/>• Padrão string/função gera ficheiros por idioma.<br/>• Objeto por idioma: cada idioma corresponde ao seu próprio padrão; `false` ignora esse idioma.<br/>• Incluir `{{locale}}` ativa a geração por idioma.<br/>• `fill` ao nível do dicionário tem sempre precedência sobre esta definição global.              |
-| `description`               | Ajuda o editor e o CMS a compreender o propósito do dicionário. Também usado como contexto para a geração de traduções assistida por IA.               | `string`                                                                                                        | `undefined` | `'Secção do perfil do utilizador'`                                                          |                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `locale`                    | Transforma o dicionário num formato por idioma. Cada campo declarado torna-se um nó de tradução. Se ausente, o dicionário é tratado como multi-idioma. | `LocalesValues`                                                                                                 | `undefined` | `'en'`                                                                                      | Use isto quando o dicionário for específico de um único idioma em vez de conter traduções para vários.                                                                                                                                                                                                                                                                                                  |
-| `contentAutoTransformation` | Transforma automaticamente as strings de conteúdo em nós tipados (markdown, HTML ou inserção).                                                         | `boolean` &#124; <br/> `{ markdown?: boolean; html?: boolean; insertion?: boolean }`                            | `false`     | `true`                                                                                      | • Markdown : `### Title` → `md('### Title')`.<br/>• HTML : `<div>Title</div>` → `html('<div>Title</div>')`.<br/>• Inserção : `Olá {{name}}` → `insert('Olá {{name}}')`.                                                                                                                                                                                                                                 |
-| `location`                  | Indica onde os ficheiros do dicionário estão armazenados e como são sincronizados com o CMS.                                                           | `'local'` &#124; <br/> `'remote'` &#124; <br/> `'hybrid'` &#124; <br/> `'plugin'` &#124; <br/> `string`         | `'local'`   | `'hybrid'`                                                                                  | • `'local'`: gerido apenas localmente.<br/>• `'remote'`: gerido apenas remotamente (CMS).<br/>• `'hybrid'`: gerido local e remotamente.<br/>• `'plugin'` ou string personalizada: gerido por um plugin ou fonte personalizada.                                                                                                                                                                          |
-| `importMode`                | Controla como os dicionários são importados.                                                                                                           | `'static'` &#124; <br/> `'dynamic'` &#124; <br/> `'fetch'`                                                      | `'static'`  | `'dynamic'`                                                                                 | • `'static'`: importado estaticamente.<br/>• `'dynamic'`: importado dinamicamente usando Suspense.<br/>• `'fetch'`: recuperado via Live Sync API; fallback para `'dynamic'` se falhar.<br/>• Requer plugins `@intlayer/babel` e `@intlayer/swc`.<br/>• Chaves devem ser declaradas estaticamente.<br/>• Ignorado se `optimize` estiver desativado.<br/>• Não afeta `getIntlayer`, `getDictionary`, etc. |
-| `priority`                  | Prioridade do dicionário. Valores mais altos vencem valores mais baixos na resolução de conflitos entre dicionários.                                   | `number`                                                                                                        | `undefined` | `1`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `live`                      | Depreciado - use `importMode: 'fetch'` em vez disso. Indicava se o conteúdo do dicionário devia ser recuperado dinamicamente via API Live Sync.        | `boolean`                                                                                                       | `undefined` |                                                                                             | Renomeado para `importMode: 'fetch'` na v8.0.0.                                                                                                                                                                                                                                                                                                                                                         |
-| `schema`                    | Gerado automaticamente pelo Intlayer para validação de esquema JSON.                                                                                   | `'https://intlayer.org/schema.json'`                                                                            | auto-gerado |                                                                                             | Não editar manualmente.                                                                                                                                                                                                                                                                                                                                                                                 |
-| `title`                     | Ajuda a identificar o dicionário no editor e CMS.                                                                                                      | `string`                                                                                                        | `undefined` | `'Perfil do Utilizador'`                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `tags`                      | Categoriza dicionários e fornece contexto ou instruções para o editor e IA.                                                                            | `string[]`                                                                                                      | `undefined` | `['utilizador', 'perfil']`                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `version`                   | Versão do dicionário remoto; ajuda a rastrear a versão atualmente em uso.                                                                              | `string`                                                                                                        | `undefined` | `'1.0.0'`                                                                                   | • Gestível no CMS.<br/>• Não editar localmente.                                                                                                                                                                                                                                                                                                                                                         |
+| Campo                       | Descrição                                                                                                                                              | Tipo                                                                                                            | Padrão       | Exemplo                                                                                     | Nota                                                                                                                                                                                                                                                                                                                                                                                                    |
+| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `fill`                      | Controla como os ficheiros de saída do preenchimento automático (tradução por IA) são gerados.                                                         | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`       | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: caminho padrão (mesmo ficheiro que a origem).<br/>• `false`: desativar.<br/>• Padrão string/função gera ficheiros por idioma.<br/>• Objeto por idioma: cada idioma corresponde ao seu próprio padrão; `false` ignora esse idioma.<br/>• Incluir `{{locale}}` ativa a geração por idioma.<br/>• `fill` ao nível do dicionário tem sempre precedência sobre esta definição global.              |
+| `description`               | Ajuda o editor e o CMS a compreender o propósito do dicionário. Também usado como contexto para a geração de traduções assistida por IA.               | `string`                                                                                                        | `undefined`  | `'Secção do perfil do utilizador'`                                                          |                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `locale`                    | Transforma o dicionário num formato por idioma. Cada campo declarado torna-se um nó de tradução. Se ausente, o dicionário é tratado como multi-idioma. | `LocalesValues`                                                                                                 | `undefined`  | `'en'`                                                                                      | Use isto quando o dicionário for específico de um único idioma em vez de conter traduções para vários.                                                                                                                                                                                                                                                                                                  |
+| `contentAutoTransformation` | Transforma automaticamente as strings de conteúdo em nós tipados (markdown, HTML ou inserção).                                                         | `boolean` &#124; <br/> `{ markdown?: boolean; html?: boolean; insertion?: boolean }`                            | `false`      | `true`                                                                                      | • Markdown : `### Title` → `md('### Title')`.<br/>• HTML : `<div>Title</div>` → `html('<div>Title</div>')`.<br/>• Inserção : `Olá {{name}}` → `insert('Olá {{name}}')`.                                                                                                                                                                                                                                 |
+| `location`                  | Indica onde os ficheiros do dicionário estão armazenados e como são sincronizados com o CMS.                                                           | `'local'` &#124; <br/> `'remote'` &#124; <br/> `'hybrid'` &#124; <br/> `'plugin'` &#124; <br/> `string`         | `'local'`    | `'hybrid'`                                                                                  | • `'local'`: gerido apenas localmente.<br/>• `'remote'`: gerido apenas remotamente (CMS).<br/>• `'hybrid'`: gerido local e remotamente.<br/>• `'plugin'` ou string personalizada: gerido por um plugin ou fonte personalizada.                                                                                                                                                                          |
+| `importMode`                | Controla como os dicionários são importados.                                                                                                           | `'static'` &#124; <br/> `'dynamic'` &#124; <br/> `'fetch'`                                                      | `'static'`   | `'dynamic'`                                                                                 | • `'static'`: importado estaticamente.<br/>• `'dynamic'`: importado dinamicamente usando Suspense.<br/>• `'fetch'`: recuperado via Live Sync API; fallback para `'dynamic'` se falhar.<br/>• Requer plugins `@intlayer/babel` e `@intlayer/swc`.<br/>• Chaves devem ser declaradas estaticamente.<br/>• Ignorado se `optimize` estiver desativado.<br/>• Não afeta `getIntlayer`, `getDictionary`, etc. |
+| `format`                    | O formato de mensagem padrão para todos os dicionários no projeto.                                                                                     | `'intlayer'` &#124; <br/> `'icu'` &#124; <br/> `'i18next'` &#124; <br/> `'vue-i18n'` &#124; <br/> `'po'`        | `'intlayer'` | `'icu'`                                                                                     | • `'intlayer'`: Formato nativo intlayer.<br/>• `'icu'`: Formato de mensagem ICU.<br/>• `'i18next'`: Formato i18next.<br/>• `'vue-i18n'`: Formato Vue I18n.<br/>• `'po'`: Formato GNU Gettext PO.                                                                                                                                                                                                        |
+| `priority`                  | Prioridade do dicionário. Valores mais altos vencem valores mais baixos na resolução de conflitos entre dicionários.                                   | `number`                                                                                                        | `undefined`  | `1`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `live`                      | Depreciado - use `importMode: 'fetch'` em vez disso. Indicava se o conteúdo do dicionário devia ser recuperado dinamicamente via API Live Sync.        | `boolean`                                                                                                       | `undefined`  |                                                                                             | Renomeado para `importMode: 'fetch'` na v8.0.0.                                                                                                                                                                                                                                                                                                                                                         |
+| `schema`                    | Gerado automaticamente pelo Intlayer para validação de esquema JSON.                                                                                   | `'https://intlayer.org/schema.json'`                                                                            | auto-gerado  |                                                                                             | Não editar manualmente.                                                                                                                                                                                                                                                                                                                                                                                 |
+| `title`                     | Ajuda a identificar o dicionário no editor e CMS.                                                                                                      | `string`                                                                                                        | `undefined`  | `'Perfil do Utilizador'`                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `tags`                      | Categoriza dicionários e fornece contexto ou instruções para o editor e IA.                                                                            | `string[]`                                                                                                      | `undefined`  | `['utilizador', 'perfil']`                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `version`                   | Versão do dicionário remoto; ajuda a rastrear a versão atualmente em uso.                                                                              | `string`                                                                                                        | `undefined`  | `'1.0.0'`                                                                                   | • Gestível no CMS.<br/>• Não editar localmente.                                                                                                                                                                                                                                                                                                                                                         |
 
 **Exemplo de `fill`**:
 
@@ -959,22 +1008,6 @@ As opções de build aplicam-se aos plugins `@intlayer/babel` e `@intlayer/swc`.
 
 ---
 
-### Configuração do Sistema
-
-Estas definições são para casos de uso avançados e configuração interna do Intlayer.
-
-| Campo                     | Descrição                                            | Tipo     | Padrão                            | Exemplo | Nota |
-| ------------------------- | ---------------------------------------------------- | -------- | --------------------------------- | ------- | ---- |
-| `dictionariesDir`         | Diretório para dicionários compilados.               | `string` | `'.intlayer/dictionary'`          |         |      |
-| `moduleAugmentationDir`   | Diretório para a augmentation de módulos TypeScript. | `string` | `'.intlayer/types'`               |         |      |
-| `unmergedDictionariesDir` | Diretório para dicionários não fundidos.             | `string` | `'.intlayer/unmerged_dictionary'` |         |      |
-| `typesDir`                | Diretório para tipos gerados.                        | `string` | `'.intlayer/types'`               |         |      |
-| `mainDir`                 | Diretório do ficheiro principal do Intlayer.         | `string` | `'.intlayer/main'`                |         |      |
-| `configDir`               | Diretório dos ficheiros de configuração compilados.  | `string` | `'.intlayer/config'`              |         |      |
-| `cacheDir`                | Diretório dos ficheiros de cache.                    | `string` | `'.intlayer/cache'`               |         |      |
-
----
-
 ### Configuração do Compilador
 
 Configurações que controlam o compilador do Intlayer, que extrai dicionários diretamente das suas componentes.

package/docs/pt/custom_domains.md

@@ -17,6 +17,7 @@ history:
   - version: 8.5.0
     date: 2026-04-02
     changes: "Adição de roteamento de locale baseado em domínio via configuração routing.domains."
+author: aymericzip
 ---
 
 # Domínios personalizados
@@ -44,12 +45,7 @@ import { Locales, type IntlayerConfig } from "intlayer";
 
 const config: IntlayerConfig = {
   internationalization: {
-    locales: [
-      Locales.ENGLISH,
-      Locales.FRENCH,
-      Locales.SPANISH,
-      Locales.CHINESE,
-    ],
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.CHINESE],
     defaultLocale: Locales.ENGLISH,
   },
   routing: {
@@ -171,10 +167,16 @@ O plugin Vite `intlayerProxy` aplica a mesma lógica durante o desenvolvimento:
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/pt/custom_url_rewrites.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-01-26
+updatedAt: 2026-06-23
 title: Reescritas de URL Personalizadas
 description: Saiba como configurar e usar reescritas de URL personalizadas no Intlayer para definir caminhos específicos por locale.
 keywords:
@@ -16,6 +16,7 @@ history:
   - version: 8.0.0
     date: 2026-01-25
     changes: "Implementar reescritas de URL centralizadas com formatadores específicos de framework e o hook useRewriteURL."
+author: aymericzip
 ---
 
 # Implementação de Reescritas de URL Personalizadas
@@ -341,10 +342,16 @@ Para SolidJS, Vue e Svelte, o plugin Vite `intlayerProxy` gerencia as reescritas
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/pt/dictionary/condition.md

@@ -16,6 +16,7 @@ slugs:
   - concept
   - content
   - condition
+author: aymericzip
 ---
 
 # Conteúdo Condicional / Condição no Intlayer
@@ -66,7 +67,10 @@ export default myConditionalContent;
 
 ## Usando Conteúdo Condicional com React Intlayer
 
-Para utilizar conteúdo condicional dentro de um componente React, importe e use o hook `useIntlayer` do pacote `react-intlayer`. Este hook busca o conteúdo para a chave especificada e permite que você passe uma condição para selecionar a saída apropriada.
+<Tabs group="framework">
+  <Tab label="React" value="react">
+
+To utilize conditional content within a React component, import and use the `useIntlayer` hook from the `react-intlayer` package. This hook fetches the content for the specified key and allows you to pass in a condition to select the appropriate output.
 
 ```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
@@ -79,25 +83,25 @@ const ConditionalComponent: FC = () => {
     <div>
       <p>
         {
-          /* Saída: meu conteúdo quando é verdadeiro */
+          /* Output: my content when it's true */
           myCondition(true)
         }
       </p>
       <p>
         {
-          /* Saída: meu conteúdo quando é falso */
+          /* Output: my content when it's false */
           myCondition(false)
         }
       </p>
       <p>
         {
-          /* Saída: meu conteúdo quando a condição falha */
+          /* Output: my content when the condition fails */
           myCondition("")
         }
       </p>
       <p>
         {
-          /* Saída: meu conteúdo quando a condição falha */
+          /* Output: my content when the condition fails */
           myCondition(undefined)
         }
       </p>
@@ -108,6 +112,165 @@ const ConditionalComponent: FC = () => {
 export default ConditionalComponent;
 ```
 
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+
+To utilize conditional content in Next.js Client Components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
+"use client";
+
+import type { FC } from "react";
+import { useIntlayer } from "next-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>{myCondition(true)}</p>
+      <p>{myCondition(false)}</p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+
+To utilize conditional content in Vue components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```vue fileName="**/*.vue"
+<script setup lang="ts">
+import { useIntlayer } from "vue-intlayer";
+
+const { myCondition } = useIntlayer("my_key");
+</script>
+
+<template>
+  <div>
+    <p>{{ myCondition(true) }}</p>
+    <p>{{ myCondition(false) }}</p>
+  </div>
+</template>
+```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+
+To utilize conditional content in Svelte components, retrieve it via the `useIntlayer` hook. The store is accessed with `$`. Here's an example:
+
+```svelte fileName="**/*.svelte"
+<script lang="ts">
+import { useIntlayer } from "svelte-intlayer";
+
+const content = useIntlayer("my_key");
+</script>
+
+<div>
+  <p>{$content.myCondition(true)}</p>
+  <p>{$content.myCondition(false)}</p>
+</div>
+```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+
+To utilize conditional content in Preact components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
+import type { FC } from "preact";
+import { useIntlayer } from "preact-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>{myCondition(true)}</p>
+      <p>{myCondition(false)}</p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+
+To utilize conditional content in SolidJS components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
+import type { Component } from "solid-js";
+import { useIntlayer } from "solid-intlayer";
+
+const ConditionalComponent: Component = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>{myCondition(true)}</p>
+      <p>{myCondition(false)}</p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+
+To utilize conditional content in Angular components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```typescript fileName="app.component.ts" codeFormat="typescript"
+import { Component } from "@angular/core";
+import { useIntlayer } from "angular-intlayer";
+
+@Component({
+  selector: "app-conditional",
+  template: `
+    <div>
+      <p>{{ content().myCondition(true) }}</p>
+      <p>{{ content().myCondition(false) }}</p>
+    </div>
+  `,
+})
+export class ConditionalComponent {
+  content = useIntlayer("my_key");
+}
+```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+
+To utilize conditional content with `vanilla-intlayer`, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
+import { installIntlayer, useIntlayer } from "vanilla-intlayer";
+
+installIntlayer();
+
+const content = useIntlayer("my_key").onChange((newContent) => {
+  document.getElementById("true-content")!.textContent =
+    newContent.myCondition(true);
+  document.getElementById("false-content")!.textContent =
+    newContent.myCondition(false);
+});
+
+// Initial render
+document.getElementById("true-content")!.textContent =
+  content.myCondition(true);
+document.getElementById("false-content")!.textContent =
+  content.myCondition(false);
+```
+
+  </Tab>
+</Tabs>
+
 ## Recursos Adicionais
 
 Para informações mais detalhadas sobre configuração e uso, consulte os seguintes recursos:

package/docs/pt/dictionary/content_file.md

@@ -36,6 +36,7 @@ history:
   - version: 5.5.10
     date: 2025-06-29
     changes: "Histórico inicial"
+author: aymericzip
 ---
 
 # Arquivo de Conteúdo
@@ -490,6 +491,66 @@ Indica a prioridade do dicionário para resolução de conflitos. Quando múltip
 // Isto irá sobrescrever o dicionário base
 ```
 
+#### `item` (número)
+
+Usado em conjunto com as Coleções, este campo define a posição do item em uma coleção. Ele permite que você crie coleções ordenadas de itens localizados selecionáveis por índice em tempo de execução.
+
+**Exemplo:**
+
+```typescript
+{
+  key: "faq",
+  item: 1,
+  content: {
+    question: "What is Intlayer?",
+    answer: "An i18n toolkit."
+  }
+}
+```
+
+> Veja [Coleções](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/collections.md) para mais informações.
+
+#### `variant` (string)
+
+Usado em conjunto com as Variantes, este campo define alternativas de conteúdo nomeadas. Ele permite que você alterne entre diferentes variações da mesma chave de dicionário em tempo de execução sem alterações no código (por exemplo, para testes A/B, banners sazonais). Se não for fornecido, será considerado como a variante padrão.
+
+**Exemplo:**
+
+```typescript
+{
+  key: "hero-banner",
+  variant: "black_friday",
+  content: {
+    headline: "50 % off — today only",
+    cta: "Shop now"
+  }
+}
+```
+
+> Veja [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/variants.md) para mais informações.
+
+#### `meta` (`Record<string, string | number | boolean>`)
+
+Usado em conjunto com os Registros Dinâmicos, este campo permite declarar registros gerenciados pelo CMS ou dados arbitrários buscados em tempo de execução por um ID opaco. A identidade do dicionário é definida pelo conjunto arbitrário de pares chave-valor declarados neste campo `meta`.
+
+**Exemplo:**
+
+```typescript
+{
+  key: "product-copy",
+  meta: {
+    id: "prod_abc",
+    userId: "user_123"
+  },
+  content: {
+    name: "Widget Pro",
+    description: "The best widget."
+  }
+}
+```
+
+> Veja [Registros Dinâmicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/dynamic_content.md) para mais informações.
+
 ### Propriedades do CMS
 
 ##### `version` (string)
@@ -518,6 +579,10 @@ Esquema JSON usado para validação da estrutura do dicionário. Adicionado auto
 
 Para dicionários remotos, este é o identificador único do dicionário no servidor remoto. Usado para buscar e gerenciar conteúdo remoto.
 
+##### `projectIds` (string[])
+
+Para dicionários remotos, este array contém os IDs dos projetos que podem usar este dicionário. Um dicionário remoto pode ser compartilhado entre vários projetos.
+
 ##### `localId` (LocalDictionaryId)
 
 Identificador único para dicionários locais. Gerado automaticamente pelo Intlayer para ajudar a identificar o dicionário e determinar se é local ou remoto, junto com sua localização.
@@ -538,13 +603,6 @@ Para dicionários remotos, este array contém todas as versões disponíveis do
 
 Indica se o dicionário foi preenchido automaticamente a partir de fontes externas. Em caso de conflitos, os dicionários base substituirão os dicionários preenchidos automaticamente.
 
-##### `location` ('distant' | 'locale')
-
-Indica a localização do dicionário:
-
-- `'locale'`: Dicionário local (a partir dos arquivos de conteúdo)
-- `'distant'`: Dicionário remoto (a partir de fonte externa)
-
 ## Tipos de Nós de Conteúdo
 
 O Intlayer fornece vários tipos especializados de nós de conteúdo que estendem valores primitivos básicos: