@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.11

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"
@@ -135,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";
 
 /**
@@ -585,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;
@@ -645,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`**:
@@ -853,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`**:
 
@@ -960,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

@@ -45,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: {
@@ -172,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:
@@ -342,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

@@ -67,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";
@@ -80,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>
@@ -109,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

@@ -579,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.
@@ -599,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: