@intlayer/docs 8.0.0 → 8.0.1-canary.1

package/docs/es/packages/adonis-intlayer/exports.md

@@ -0,0 +1,50 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: Documentación del paquete adonis-intlayer
+description: Middleware de AdonisJS para Intlayer, que proporciona funciones de traducción y detección de locale.
+keywords:
+  - adonis-intlayer
+  - adonisjs
+  - middleware
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - exports
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Documentación inicial
+---
+
+# Paquete adonis-intlayer
+
+El paquete `adonis-intlayer` proporciona un middleware para aplicaciones AdonisJS para manejar la internacionalización. Detecta el locale del usuario y proporciona funciones de traducción.
+
+## Instalación
+
+```bash
+npm install adonis-intlayer
+```
+
+## Exportaciones
+
+### Middleware
+
+El paquete proporciona un middleware de AdonisJS para manejar la internacionalización.
+
+| Función              | Descripción                                                                                                                                                                                                                                                                                                     | Doc relacionada                                                                                                |
+| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `IntlayerMiddleware` | Middleware de AdonisJS que detecta el locale del usuario y rellena el contexto de la solicitud con datos de Intlayer. También configura un espacio de nombres CLS (Async Local Storage) para el acceso al ciclo de vida de la solicitud, habilitando el uso de funciones globales como `t`, `getIntlayer`, etc. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/adonis-intlayer/intlayer.md) |
+
+### Funciones
+
+| Función         | Descripción                                                                                                                                                                                                                                   | Doc relacionada                                                                                       |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `t`             | Función de traducción que recupera el contenido para el locale actual. Funciona dentro del ciclo de vida de la solicitud gestionado por el middleware `intlayer`. Utiliza CLS (Async Local Storage) para acceder al contexto de la solicitud. | [traducción](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dictionary/translation.md) |
+| `getIntlayer`   | Recupera un diccionario por su clave de la declaración generada y devuelve su contenido para el locale especificado. Versión optimizada de `getDictionary`. Utiliza CLS para acceder al contexto de la solicitud.                             | -                                                                                                     |
+| `getDictionary` | Procesa objetos de diccionario y devuelve el contenido para el locale especificado. Procesa traducciones `t()`, enumeraciones, markdown, HTML, etc. Utiliza CLS para acceder al contexto de la solicitud.                                     | -                                                                                                     |
+| `getLocale`     | Recupera el locale actual del contexto de la solicitud usando CLS.                                                                                                                                                                            | -                                                                                                     |

package/docs/es/packages/adonis-intlayer/intlayer.md

@@ -0,0 +1,54 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: Documentación del Middleware AdonisJS Intlayer | adonis-intlayer
+description: Vea cómo usar el middleware intlayer para el paquete adonis-intlayer
+keywords:
+  - intlayer
+  - adonisjs
+  - middleware
+  - Intlayer
+  - Internacionalización
+  - Documentación
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - intlayer
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Documentación inicial
+---
+
+# Documentación del Middleware AdonisJS Intlayer
+
+El middleware `intlayer` para AdonisJS detecta el locale del usuario y proporciona funciones de traducción a través del contexto de la solicitud. También habilita el uso de funciones de traducción globales dentro del flujo de la solicitud.
+
+## Uso
+
+```ts fileName="start/kernel.ts"
+router.use([() => import("adonis-intlayer/middleware")]);
+```
+
+```ts fileName="start/routes.ts"
+import router from "@adonisjs/core/services/router";
+import { t } from "adonis-intlayer";
+
+router.get("/", async () => {
+  return t({
+    en: "Hello",
+    fr: "Bonjour",
+  });
+});
+```
+
+## Descripción
+
+El middleware realiza las siguientes tareas:
+
+1. **Detección de Locale**: Analiza la solicitud (encabezados, cookies, etc.) para determinar el locale preferido del usuario.
+2. **Configuración del Contexto**: Rellena el contexto de la solicitud con información del locale.
+3. **Async Local Storage**: Utiliza `cls-hooked` para gestionar un contexto asíncrono, permitiendo que las funciones globales de Intlayer como `t`, `getIntlayer` y `getDictionary` accedan al locale específico de la solicitud sin tener que pasarlo manualmente.
+
+> Nota: Para usar cookies para la detección del locale, asegúrese de que `@adonisjs/cookie` esté configurado y se use en su aplicación.

package/docs/es/packages/adonis-intlayer/t.md

@@ -0,0 +1,149 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: Documentación de la función t | adonis-intlayer
+description: Vea cómo usar la función t para el paquete adonis-intlayer
+keywords:
+  - t
+  - traducción
+  - Intlayer
+  - Internacionalización
+  - Documentación
+  - AdonisJS
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - t
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Documentación inicial
+---
+
+# Documentación: Función `t` en `adonis-intlayer`
+
+La función `t` en el paquete `adonis-intlayer` es la utilidad principal para proporcionar respuestas localizadas en su aplicación AdonisJS. Simplifica la internacionalización (i18n) al seleccionar dinámicamente el contenido basado en el idioma preferido del usuario.
+
+---
+
+## Resumen
+
+La función `t` se utiliza para definir y recuperar traducciones para un conjunto dado de idiomas. Determina automáticamente el idioma apropiado para devolver basándose en la configuración de la solicitud del cliente, como el encabezado `Accept-Language`. Si el idioma preferido no está disponible, recurre con elegancia al locale predeterminado especificado en su configuración.
+
+---
+
+## Características Clave
+
+- **Localización Dinámica**: Selecciona automáticamente la traducción más adecuada para el cliente.
+- **Respaldo al Locale Predeterminado**: Recurre a un locale predeterminado si el idioma preferido del cliente no está disponible, garantizando la continuidad en la experiencia del usuario.
+- **Contexto Asíncrono**: Funciona a la perfección dentro del ciclo de vida de la solicitud de AdonisJS utilizando Async Local Storage.
+- **Soporte de TypeScript**: Aplique seguridad de tipos para sus traducciones.
+
+---
+
+## Firma de la Función
+
+```typescript
+t(translations: Record<string, any>): any;
+```
+
+### Parámetros
+
+- `translations`: Un objeto donde las claves son códigos de locale (por ejemplo, `en`, `fr`, `es`) y los valores son el contenido traducido correspondiente.
+
+### Retornos
+
+- El contenido que representa el idioma preferido del cliente.
+
+---
+
+## Carga del Middleware
+
+Para asegurar que la función `t` funcione correctamente, **debe** registrar el middleware `intlayer` en su aplicación AdonisJS.
+
+```typescript fileName="start/kernel.ts"
+router.use([() => import("adonis-intlayer/middleware")]);
+```
+
+---
+
+## Ejemplos de Uso
+
+### Ejemplo Básico
+
+```typescript fileName="start/routes.ts"
+import router from "@adonisjs/core/services/router";
+import { t } from "adonis-intlayer";
+
+router.get("/", async () => {
+  return t({
+    en: "Welcome!",
+    fr: "Bienvenue !",
+    es: "¡Bienvenido!",
+  });
+});
+```
+
+### Uso en Controladores
+
+```typescript fileName="app/controllers/example_controller.ts"
+import type { HttpContext } from "@adonisjs/core/http";
+import { t } from "adonis-intlayer";
+
+export default class ExampleController {
+  async index({ response }: HttpContext) {
+    return response.send(
+      t({
+        en: "Hello from controller",
+        fr: "Bonjour desde el controlador",
+      })
+    );
+  }
+}
+```
+
+---
+
+## Temas Avanzados
+
+### Mecanismo de Respaldo
+
+Si un locale preferido no está disponible, la función `t` recurrirá al locale predeterminado definido en su archivo `intlayer.config.ts`.
+
+```typescript
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [
+      Locales.ENGLISH,
+      Locales.RUSSIAN,
+      Locales.JAPANESE,
+      Locales.FRENCH,
+      Locales.KOREAN,
+      Locales.CHINESE,
+      Locales.SPANISH,
+      Locales.GERMAN,
+      Locales.ARABIC,
+      Locales.ITALIAN,
+      Locales.ENGLISH_UNITED_KINGDOM,
+      Locales.PORTUGUESE,
+      Locales.HINDI,
+      Locales.TURKISH,
+      Locales.POLISH,
+      Locales.INDONESIAN,
+      Locales.VIETNAMESE,
+      Locales.UKRAINIAN,
+    ],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+### Integración con TypeScript
+
+La función `t` es segura en cuanto a tipos cuando se utiliza con diccionarios definidos. Para más detalles, consulte la [documentación de TypeScript](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/configuration.md).

package/docs/es/packages/hono-intlayer/exports.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-01-29
+updatedAt: 2026-01-29
+title: Documentación del Paquete hono-intlayer
+description: Middleware de Hono para Intlayer, proporcionando funciones de traducción y detección de idioma.
+keywords:
+  - hono-intlayer
+  - hono
+  - middleware
+  - internacionalización
+  - i18n
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - exports
+history:
+  - version: 8.0.0
+    date: 2026-01-29
+    changes: Documentación unificada para todas las exportaciones
+---
+
+# Paquete hono-intlayer
+
+El paquete `hono-intlayer` proporciona un middleware para aplicaciones Hono para manejar la internacionalización. Detecta el idioma del usuario y rellena el objeto de contexto.
+
+## Instalación
+
+```bash
+npm install hono-intlayer
+```
+
+## Exportaciones
+
+### Middleware
+
+Importar:
+
+```tsx
+import { intlayer } from "hono-intlayer";
+```
+
+| Función    | Descripción                                                                                                                                                                                                                                                                                                            | Doc Relacionada                                                                                              |
+| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `intlayer` | Middleware de Hono que integra Intlayer en su aplicación Hono. Maneja la detección de idioma desde el almacenamiento (cookies, encabezados), rellena el contexto con `t`, `getIntlayer` y `getDictionary`, y configura el espacio de nombres CLS para el acceso programático durante el ciclo de vida de la solicitud. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/packages/hono-intlayer/intlayer.md) |
+
+### Funciones
+
+Importar:
+
+```tsx
+import { t, getIntlayer, getDictionary } from "hono-intlayer";
+```
+
+| Función         | Descripción                                                                                                                                                                                                                                                       | Doc Relacionada                                                                                       |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `t`             | Función de traducción global que recupera contenido para el idioma actual en Hono. Utiliza CLS (Async Local Storage) y debe usarse dentro de un contexto de solicitud gestionado por el middleware `intlayer`. También se puede acceder a través del contexto.    | [traducción](https://github.com/aymericzip/intlayer/blob/main/docs/docs/es/dictionary/translation.md) |
+| `getIntlayer`   | Recupera un diccionario por su clave de la declaración generada y devuelve su contenido para el idioma especificado. Versión optimizada de `getDictionary`. Utiliza CLS para acceder al contexto de la solicitud. También se puede acceder a través del contexto. | -                                                                                                     |
+| `getDictionary` | Procesa objetos de diccionario y devuelve el contenido para el idioma especificado. Procesa traducciones `t()`, enumeraciones, markdown, HTML, etc. Utiliza CLS para acceder al contexto de la solicitud. También se puede acceder a través del contexto.         | -                                                                                                     |

package/docs/es/packages/hono-intlayer/intlayer.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-01-29
+updatedAt: 2026-01-29
+title: Documentación del Middleware de Hono intlayer | hono-intlayer
+description: Vea cómo usar el middleware intlayer para el paquete hono-intlayer
+keywords:
+  - intlayer
+  - hono
+  - middleware
+  - Intlayer
+  - Internacionalización
+  - Documentación
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - intlayer
+history:
+  - version: 8.0.0
+    date: 2026-01-29
+    changes: Inicio de la doc
+---
+
+# Documentación del Middleware de Hono intlayer
+
+El middleware `intlayer` para Hono detecta el idioma del usuario y rellena el objeto de contexto con las funciones de Intlayer. También permite el uso de funciones de traducción globales dentro del contexto de la solicitud.
+
+## Uso
+
+```ts
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+app.use("*", intlayer());
+
+app.get("/", async (c) => {
+  const t = c.get("t");
+  const content = t({
+    en: "Hello",
+    fr: "Bonjour",
+  });
+
+  return c.text(content);
+});
+```
+
+## Descripción
+
+El middleware realiza las siguientes tareas:
+
+1. **Detección de idioma**: Analiza la solicitud (encabezados, cookies, etc.) para determinar el idioma preferido del usuario.
+2. **Relleno del contexto**: Añade datos de Intlayer al contexto de Hono, accesibles a través de `c.get()`. Esto incluye:
+   - `locale`: El idioma detectado.
+   - `t`: Una función de traducción.
+   - `getIntlayer`: Una función para recuperar diccionarios.
+   - `getDictionary`: Una función para procesar objetos de diccionario.
+3. **Gestión del contexto**: Utiliza `cls-hooked` para gestionar un contexto asíncrono, permitiendo que las funciones globales de Intlayer (`t`, `getIntlayer`, `getDictionary`) accedan al idioma específico de la solicitud sin pasar el objeto de contexto.

package/docs/es/packages/hono-intlayer/t.md

@@ -0,0 +1,316 @@
+---
+createdAt: 2024-12-02
+updatedAt: 2025-06-29
+title: Documentación de la Función t | hono-intlayer
+description: Vea cómo usar la función t para el paquete hono-intlayer
+keywords:
+  - t
+  - traducción
+  - Intlayer
+  - Internacionalización
+  - Documentación
+  - Hono
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - t
+history:
+  - version: 5.5.10
+    date: 2025-06-29
+    changes: Inicio del historial
+---
+
+# Documentación: Función `t` en `hono-intlayer`
+
+La función `t` en el paquete `hono-intlayer` es la utilidad principal para proporcionar respuestas localizadas en su aplicación Hono. Simplifica la internacionalización (i18n) al seleccionar dinámicamente el contenido basado en el idioma preferido del usuario.
+
+---
+
+## Descripción General
+
+La función `t` se utiliza para definir y recuperar traducciones para un conjunto dado de idiomas. Determina automáticamente el idioma apropiado para devolver basándose en la configuración de la solicitud del cliente, como el encabezado `Accept-Language`. Si el idioma preferido no está disponible, recurre elegantemente al idioma predeterminado especificado en su configuración.
+
+---
+
+## Características Clave
+
+- **Localización Dinámica**: Selecciona automáticamente la traducción más adecuada para el cliente.
+- **Respaldo al Idioma Predeterminado**: Recurre a un idioma predeterminado si el idioma preferido del cliente no está disponible, asegurando la continuidad en la experiencia del usuario.
+- **Ligero y Rápido**: Diseñado para aplicaciones de alto rendimiento, garantizando un impacto mínimo.
+- **Soporte de Modo Estricto**: Refuerza el cumplimiento estricto de los idiomas declarados para un comportamiento confiable.
+
+---
+
+## Firma de la Función
+
+```typescript
+t(translations: Record<string, string>): string;
+```
+
+### Parámetros
+
+- `translations`: Un objeto donde las claves son códigos de idioma (por ejemplo, `en`, `fr`, `es-MX`) y los valores son las cadenas traducidas correspondientes.
+
+### Retorno
+
+- Una cadena que representa el contenido en el idioma preferido del cliente.
+
+---
+
+## Carga del Controlador de Solicitudes de Internacionalización
+
+Para asegurar que la funcionalidad de internacionalización proporcionada por `hono-intlayer` funcione correctamente, **debe** cargar el middleware de internacionalización al principio de su aplicación Hono. Esto habilita la función `t` y asegura el manejo adecuado de la detección de idioma y la traducción.
+
+Coloque el middleware `app.use("*", intlayer())` **antes de cualquier ruta** en su aplicación para asegurar que todas las rutas se beneficien de la internacionalización:
+
+```typescript {6} fileName="src/index.ts" codeFormat="typescript"
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+// Cargar el controlador de solicitudes de internacionalización
+app.use("*", intlayer());
+
+// Defina sus rutas después de cargar el middleware
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {6} fileName="src/index.mjs" codeFormat="esm"
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+// Cargar el controlador de solicitudes de internacionalización
+app.use("*", intlayer());
+
+// Defina sus rutas después de cargar el middleware
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {6} fileName="src/index.cjs" codeFormat="commonjs"
+const { Hono } = require("hono");
+const { intlayer, t } = require("hono-intlayer");
+
+const app = new Hono();
+
+// Cargar el controlador de solicitudes de internacionalización
+app.use("*", intlayer());
+
+// Defina sus rutas después de cargar el middleware
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+### Por Qué Esto es Necesario
+
+- **Detección de Idioma**: El middleware `intlayer` procesa las solicitudes entrantes para detectar el idioma preferido del usuario basado en encabezados, cookies u otros métodos configurados.
+- **Contexto de Traducción**: Configura el contexto necesario para que la función `t` funcione correctamente, asegurando que las traducciones se devuelvan en el idioma correcto.
+- **Prevención de Errores**: Sin este middleware, el uso de la función `t` resultará en errores de ejecución porque la información de idioma necesaria no estará disponible.
+
+---
+
+## Ejemplos de Uso
+
+### Ejemplo Básico
+
+Servir contenido localizado en diferentes idiomas:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+**Solicitudes del Cliente:**
+
+- Un cliente con `Accept-Language: fr` recibirá `Bienvenue!`.
+- Un cliente con `Accept-Language: es` recibirá `¡Bienvenido!`.
+- Un cliente con `Accept-Language: de` recibirá `Welcome!` (idioma predeterminado).
+
+### Manejo de Errores
+
+Proporcionar mensajes de error en varios idiomas:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/error", (c) => {
+  return c.text(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    }),
+    500
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/error", (c) => {
+  return c.text(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    }),
+    500
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/error", (c) => {
+  return c.text(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    }),
+    500
+  );
+});
+```
+
+---
+
+### Uso de Variantes de Idioma
+
+Especifique traducciones para variantes específicas de idioma:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/greet", (c) => {
+  return c.text(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+---
+
+## Temas Avanzados
+
+### Mecanismo de Respaldo
+
+Si un idioma preferido no está disponible, la función `t` recurrirá al idioma predeterminado definido en la configuración:
+
+```typescript {5-6} fileName="intlayer.config.ts" codeFormat="typescript"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+} satisfies IntlayerConfig;
+
+export default config;
+```
+
+---
+
+### Refuerzo del Modo Estricto
+
+Configure la función `t` para reforzar el cumplimiento estricto de los idiomas declarados:
+
+| Modo        | Comportamiento                                                                                                  |
+| ----------- | --------------------------------------------------------------------------------------------------------------- |
+| `strict`    | Todos los idiomas declarados deben tener traducciones proporcionadas. Los idiomas faltantes lanzarán errores.   |
+| `inclusive` | Los idiomas declarados deben tener traducciones. Los idiomas faltantes activan advertencias pero son aceptados. |
+| `loose`     | Cualquier idioma existente es aceptado, incluso si no está declarado.                                           |
+
+---
+
+### Integración con TypeScript
+
+La función `t` es segura en cuanto a tipos cuando se usa con TypeScript. Defina un objeto de traducciones seguro:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+import { type LanguageContent } from "hono-intlayer";
+
+const translations: LanguageContent<string> = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (c) => {
+  return c.text(t(translations));
+});
+```
+
+---
+
+### Errores Comunes y Solución de Problemas
+
+| Problema                        | Causa                                          | Solución                                                                 |
+| ------------------------------- | ---------------------------------------------- | ------------------------------------------------------------------------ |
+| La función `t` no funciona      | Middleware no cargado                          | Asegúrese de que `app.use("*", intlayer())` se añada antes de las rutas. |
+| Error de traducciones faltantes | Modo estricto habilitado sin todos los idiomas | Proporcione todas las traducciones requeridas.                           |
+
+---
+
+## Conclusión
+
+La función `t` es una herramienta poderosa para la internacionalización en el backend. Al usarla de manera efectiva, puede crear una aplicación más inclusiva y fácil de usar para una audiencia global. Para un uso avanzado y opciones de configuración detalladas, consulte la [documentación](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/configuration.md).