@intlayer/docs 8.0.0 → 8.0.1-canary.1

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

@@ -0,0 +1,50 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: Dokumentacja pakietu adonis-intlayer
+description: Middleware AdonisJS dla Intlayer, zapewniający funkcje tłumaczenia i wykrywanie ustawień regionalnych.
+keywords:
+  - adonis-intlayer
+  - adonisjs
+  - middleware
+  - internacjonalizacja
+  - i18n
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - exports
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Dokumentacja początkowa
+---
+
+# Pakiet adonis-intlayer
+
+Pakiet `adonis-intlayer` zapewnia oprogramowanie pośredniczące dla aplikacji AdonisJS do obsługi internacjonalizacji. Wykrywa ustawienia regionalne użytkownika i zapewnia funkcje tłumaczenia.
+
+## Instalacja
+
+```bash
+npm install adonis-intlayer
+```
+
+## Eksporty
+
+### Middleware
+
+Pakiet zapewnia middleware AdonisJS do obsługi internacjonalizacji.
+
+| Funkcja              | Opis                                                                                                                                                                                                                                                                                              | Powiązana dokumentacja                                                                                         |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `IntlayerMiddleware` | Middleware AdonisJS, który wykrywa ustawienia regionalne użytkownika i wypełnia kontekst żądania danymi Intlayer. Ustawia również przestrzeń nazw CLS (Async Local Storage) dla dostępu do cyklu życia żądania, umożliwiając korzystanie z globalnych funkcji, takich jak `t`, `getIntlayer` itp. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/adonis-intlayer/intlayer.md) |
+
+### Funkcje
+
+| Funkcja         | Opis                                                                                                                                                                                                                   | Powiązana dokumentacja                                                                                 |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Funkcja tłumaczenia, która pobiera treść dla bieżącego ustawienia regionalnego. Działa w cyklu życia żądania zarządzanym przez middleware `intlayer`. Używa CLS (Async Local Storage) do dostępu do kontekstu żądania. | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dictionary/translation.md) |
+| `getIntlayer`   | Pobiera słownik za pomocą jego klucza z wygenerowanej deklaracji i zwraca jego treść dla określonego ustawienia regionalnego. Zoptymalizowana wersja `getDictionary`. Używa CLS do dostępu do kontekstu żądania.       | -                                                                                                      |
+| `getDictionary` | Przetwarza obiekty słownika i zwraca treść dla określonego ustawienia regionalnego. Przetwarza tłumaczenia `t()`, wyliczenia, markdown, HTML itp. Używa CLS do dostępu do kontekstu żądania.                           | -                                                                                                      |
+| `getLocale`     | Pobiera bieżące ustawienie regionalne z kontekstu żądania za pomocą CLS.                                                                                                                                               | -                                                                                                      |

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

@@ -0,0 +1,54 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: Dokumentacja oprogramowania pośredniczącego intlayer dla AdonisJS | adonis-intlayer
+description: Zobacz, jak używać middleware intlayer w pakiecie adonis-intlayer
+keywords:
+  - intlayer
+  - adonisjs
+  - middleware
+  - Intlayer
+  - Internacjonalizacja
+  - Dokumentacja
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - intlayer
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Dokumentacja początkowa
+---
+
+# Dokumentacja oprogramowania pośredniczącego intlayer dla AdonisJS
+
+Middleware `intlayer` dla AdonisJS wykrywa ustawienia regionalne użytkownika i zapewnia funkcje tłumaczenia poprzez kontekst żądania. Umożliwia również korzystanie z globalnych funkcji tłumaczenia w ramach przepływu żądania.
+
+## Użycie
+
+```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",
+  });
+});
+```
+
+## Opis
+
+Middleware wykonuje następujące zadania:
+
+1. **Wykrywanie ustawień regionalnych**: Analizuje żądanie (nagłówki, ciasteczka itp.) w celu określenia preferowanych ustawień regionalnych użytkownika.
+2. **Konfiguracja kontekstu**: Wypełnia kontekst żądania informacjami o ustawieniach regionalnych.
+3. **Async Local Storage**: Używa `cls-hooked` do zarządzania asynchronicznym kontekstem, umożliwiając globalnym funkcjom Intlayer, takim jak `t`, `getIntlayer` i `getDictionary`, dostęp do ustawień regionalnych specyficznych dla żądania bez konieczności ich ręcznego przekazywania.
+
+> Uwaga: Aby używać ciasteczek do wykrywania ustawień regionalnych, upewnij się, że `@adonisjs/cookie` jest skonfigurowane i używane w Twojej aplikacji.

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

@@ -0,0 +1,149 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: Dokumentacja funkcji t | adonis-intlayer
+description: Zobacz, jak używać funkcji t w pakiecie adonis-intlayer
+keywords:
+  - t
+  - tłumaczenie
+  - Intlayer
+  - Internacjonalizacja
+  - Dokumentacja
+  - AdonisJS
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - t
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Dokumentacja początkowa
+---
+
+# Dokumentacja: Funkcja `t` w `adonis-intlayer`
+
+Funkcja `t` w pakiecie `adonis-intlayer` jest głównym narzędziem do dostarczania zlokalizowanych odpowiedzi w aplikacji AdonisJS. Upraszcza internacjonalizację (i18n) poprzez dynamiczne wybieranie treści na podstawie preferowanego języka użytkownika.
+
+---
+
+## Przegląd
+
+Funkcja `t` służy do definiowania i pobierania tłumaczeń dla danego zestawu języków. Automatycznie określa odpowiedni język do zwrócenia na podstawie ustawień żądania klienta, takich jak nagłówek `Accept-Language`. Jeśli preferowany język jest niedostępny, płynnie powraca do domyślnego ustawienia regionalnego określonego w konfiguracji.
+
+---
+
+## Kluczowe cechy
+
+- **Dynamiczna lokalizacja**: Automatycznie wybiera najbardziej odpowiednie tłumaczenie dla klienta.
+- **Powrót do domyślnego ustawienia regionalnego (Fallback)**: Powraca do domyślnego ustawienia regionalnego, jeśli preferowany język klienta jest niedostępny, zapewniając ciągłość doświadczenia użytkownika.
+- **Kontekst asynchroniczny**: Działa bezproblemowo w cyklu życia żądania AdonisJS przy użyciu Async Local Storage.
+- **Wsparcie TypeScript**: Wymusza bezpieczeństwo typów dla Twoich tłumaczeń.
+
+---
+
+## Sygnatura funkcji
+
+```typescript
+t(translations: Record<string, any>): any;
+```
+
+### Parametry
+
+- `translations`: Obiekt, w którym kluczami są kody ustawień regionalnych (np. `en`, `fr`, `es`), a wartościami są odpowiednie przetłumaczone treści.
+
+### Zwraca
+
+- Treść reprezentującą preferowany język klienta.
+
+---
+
+## Ładowanie oprogramowania pośredniczącego (Middleware)
+
+Aby upewnić się, że funkcja `t` działa poprawnie, **musisz** zarejestrować middleware `intlayer` w swojej aplikacji AdonisJS.
+
+```typescript fileName="start/kernel.ts"
+router.use([() => import("adonis-intlayer/middleware")]);
+```
+
+---
+
+## Przykłady użycia
+
+### Podstawowy przykład
+
+```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!",
+  });
+});
+```
+
+### Użycie w kontrolerach
+
+```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 od kontrolera",
+      })
+    );
+  }
+}
+```
+
+---
+
+## Tematy zaawansowane
+
+### Mechanizm Fallback
+
+Jeśli preferowane ustawienie regionalne jest niedostępny, funkcja `t` powróci do domyślnego ustawienia regionalnego zdefiniowanego w `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;
+```
+
+### Integracja z TypeScript
+
+Funkcja `t` jest bezpieczna pod względem typów, gdy jest używana ze zdefiniowanymi słownikami. Więcej szczegółów znajdziesz w [dokumentacji TypeScript](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/configuration.md).

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

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-01-29
+updatedAt: 2026-01-29
+title: Dokumentacja Pakietu hono-intlayer
+description: Middleware Hono dla Intlayer, dostarczający funkcje tłumaczenia i wykrywanie języka.
+keywords:
+  - hono-intlayer
+  - hono
+  - middleware
+  - internacjonalizacja
+  - i18n
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - exports
+history:
+  - version: 8.0.0
+    date: 2026-01-29
+    changes: Zunifikowana dokumentacja dla wszystkich eksportów
+---
+
+# Pakiet hono-intlayer
+
+Pakiet `hono-intlayer` dostarcza middleware dla aplikacji Hono do obsługi internacjonalizacji. Wykrywa język użytkownika i uzupełnia obiekt kontekstu.
+
+## Instalacja
+
+```bash
+npm install hono-intlayer
+```
+
+## Eksporty
+
+### Middleware
+
+Import:
+
+```tsx
+import { intlayer } from "hono-intlayer";
+```
+
+| Funkcja    | Opis                                                                                                                                                                                                                                                                                | Powiązana Dok.                                                                                               |
+| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `intlayer` | Middleware Hono integrujące Intlayer z Twoją aplikacją Hono. Obsługuje wykrywanie języka z pamięci masowej (pliki cookie, nagłówki), uzupełnia kontekst o `t`, `getIntlayer` i `getDictionary` oraz konfiguruje przestrzeń nazw CLS dla dostępu programowego w cyklu życia żądania. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/packages/hono-intlayer/intlayer.md) |
+
+### Funkcje
+
+Import:
+
+```tsx
+import { t, getIntlayer, getDictionary } from "hono-intlayer";
+```
+
+| Funkcja         | Opis                                                                                                                                                                                                                                  | Powiązana Dok.                                                                                         |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Globalna funkcja tłumaczenia pobierająca treść dla aktualnego języka w Hono. Wykorzystuje CLS (Async Local Storage) i musi być używana w kontekście żądania zarządzanym przez middleware `intlayer`. Dostępna również przez kontekst. | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pl/dictionary/translation.md) |
+| `getIntlayer`   | Pobiera słownik według klucza z wygenerowanej deklaracji i zwraca jego treść dla określonego języka. Zoptymalizowana wersja `getDictionary`. Używa CLS do dostępu do kontekstu żądania. Dostępna również przez kontekst.              | -                                                                                                      |
+| `getDictionary` | Przetwarza obiekty słownika i zwraca treść dla określonego języka. Przetwarza tłumaczenia `t()`, wyliczenia, markdown, HTML itp. Używa CLS do dostępu do kontekstu żądania. Dostępna również przez kontekst.                          | -                                                                                                      |

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

@@ -0,0 +1,60 @@
+---
+createdAt: 2026-01-29
+updatedAt: 2026-01-29
+title: Dokumentacja Middleware intlayer dla Hono | hono-intlayer
+description: Zobacz jak używać middleware intlayer dla pakietu hono-intlayer
+keywords:
+  - intlayer
+  - hono
+  - middleware
+  - Intlayer
+  - Internacjonalizacja
+  - Dokumentacja
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - intlayer
+history:
+  - version: 8.0.0
+    date: 2026-01-29
+    changes: Inicjalizacja dokumentacji
+---
+
+# Dokumentacja Middleware intlayer dla Hono
+
+Middleware `intlayer` dla Hono wykrywa język użytkownika i uzupełnia obiekt kontekstu o funkcje Intlayer. Umożliwia również korzystanie z globalnych funkcji tłumaczenia w kontekście żądania.
+
+## Użycie
+
+```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",
+    pl: "Witaj",
+  });
+
+  return c.text(content);
+});
+```
+
+## Opis
+
+Middleware wykonuje następujące zadania:
+
+1. **Wykrywanie Języka**: Analizuje żądanie (nagłówki, pliki cookie itp.) w celu określenia preferowanego języka użytkownika.
+2. **Uzupełnianie Kontekstu**: Dodaje dane Intlayer do kontekstu Hono, dostępne poprzez `c.get()`. Obejmuje to:
+   - `locale`: Wykryty język.
+   - `t`: Funkcja tłumaczenia.
+   - `getIntlayer`: Funkcja do pobierania słowników.
+   - `getDictionary`: Funkcja do przetwarzania obiektów słownika.
+3. **Zarządzanie Kontekstem**: Używa `cls-hooked` do zarządzania asynchronicznym kontekstem, co pozwala globalnym funkcjom Intlayer (`t`, `getIntlayer`, `getDictionary`) na dostęp do języka specyficznego dla żądania bez przekazywania obiektu kontekstu.

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

@@ -0,0 +1,268 @@
+---
+createdAt: 2024-12-02
+updatedAt: 2025-06-29
+title: Dokumentacja Funkcji t | hono-intlayer
+description: Zobacz jak używać funkcji t dla pakietu hono-intlayer
+keywords:
+  - t
+  - tłumaczenie
+  - Intlayer
+  - Internacjonalizacja
+  - Dokumentacja
+  - Hono
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - t
+history:
+  - version: 5.5.10
+    date: 2025-06-29
+    changes: Inicjalizacja historii
+---
+
+# Dokumentacja: Funkcja `t` w `hono-intlayer`
+
+Funkcja `t` w pakiecie `hono-intlayer` jest podstawowym narzędziem do dostarczania zlokalizowanych odpowiedzi w Twojej aplikacji Hono. Upraszcza internacjonalizację (i18n) poprzez dynamiczne wybieranie treści na podstawie preferowanego języka użytkownika.
+
+---
+
+## Przegląd
+
+Funkcja `t` służy do definiowania i pobierania tłumaczeń dla danego zestawu języków. Automatycznie określa odpowiedni język do zwrócenia na podstawie ustawień żądania klienta, takich jak nagłówek `Accept-Language`. Jeśli preferowany język jest niedostępny, funkcja płynnie powraca do domyślnego ustawienia regionalnego określonego w konfiguracji.
+
+---
+
+## Kluczowe Cechy
+
+- **Dynamiczna Lokalizacja**: Automatycznie wybiera najbardziej odpowiednie tłumaczenie dla klienta.
+- **Powrót do Domyślnego Ustawienia Regionalnego**: Wraca do domyślnego języka, jeśli preferowany język klienta nie jest dostępny, zapewniając ciągłość doświadczenia użytkownika.
+- **Lekka i Szybka**: Zaprojektowana dla aplikacji o wysokiej wydajności, zapewniając minimalny narzut.
+- **Obsługa Trybu Ścisłego**: Wymusza ścisłe przestrzeganie zadeklarowanych ustawień regionalnych dla niezawodnego zachowania.
+
+---
+
+## Sygnatura Funkcji
+
+```typescript
+t(translations: Record<string, string>): string;
+```
+
+### Parametry
+
+- `translations`: Obiekt, w którym kluczami są kody ustawień regionalnych (np. `en`, `fr`, `pl`), a wartościami są odpowiadające im przetłumaczone ciągi znaków.
+
+### Zwraca
+
+- Ciąg znaków reprezentujący treść w preferowanym języku klienta.
+
+---
+
+## Ładowanie Obsługi Żądań Internacjonalizacji
+
+Aby zapewnić poprawne działanie funkcji internacjonalizacji dostarczanych przez `hono-intlayer`, **musisz** załadować oprogramowanie pośredniczące (middleware) internacjonalizacji na początku swojej aplikacji Hono. Umożliwia to działanie funkcji `t` i zapewnia prawidłową obsługę wykrywania języka i tłumaczenia.
+
+Umieść oprogramowanie pośredniczące `app.use("*", intlayer())` **przed jakimikolwiek trasami** w swojej aplikacji, aby upewnić się, że wszystkie trasy korzystają z internacjonalizacji:
+
+```typescript {6} fileName="src/index.ts" codeFormat="typescript"
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+// Załaduj obsługę żądań internacjonalizacji
+app.use("*", intlayer());
+
+// Zdefiniuj trasy po załadowaniu oprogramowania pośredniczącego
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+      pl: "Witaj świecie!",
+    })
+  );
+});
+```
+
+```javascript {6} fileName="src/index.mjs" codeFormat="esm"
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+// Załaduj obsługę żądań internacjonalizacji
+app.use("*", intlayer());
+
+// Zdefiniuj trasy po załadowaniu oprogramowania pośredniczącego
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+      pl: "Witaj świecie!",
+    })
+  );
+});
+```
+
+```javascript {6} fileName="src/index.cjs" codeFormat="commonjs"
+const { Hono } = require("hono");
+const { intlayer, t } = require("hono-intlayer");
+
+const app = new Hono();
+
+// Załaduj obsługę żądań internacjonalizacji
+app.use("*", intlayer());
+
+// Zdefiniuj trasy po załadowaniu oprogramowania pośredniczącego
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+      pl: "Witaj świecie!",
+    })
+  );
+});
+```
+
+### Dlaczego Jest To Wymagane
+
+- **Wykrywanie Języka**: Middleware `intlayer` przetwarza przychodzące żądania w celu wykrycia preferowanego języka użytkownika na podstawie nagłówków, plików cookie lub innych skonfigurowanych metod.
+- **Kontekst Tłumaczenia**: Ustawia niezbędny kontekst, aby funkcja `t` działała poprawnie, zapewniając zwracanie tłumaczeń w odpowiednim języku.
+- **Zapobieganie Błędom**: Bez tego oprogramowania pośredniczącego użycie funkcji `t` spowoduje błędy wykonania, ponieważ niezbędne informacje o języku nie będą dostępne.
+
+---
+
+## Przykłady Użycia
+
+### Podstawowy Przykład
+
+Serwuj zlokalizowaną treść w różnych językach:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      pl: "Witaj!",
+    })
+  );
+});
+```
+
+**Żądania Klienta:**
+
+- Klient z `Accept-Language: fr` otrzyma `Bienvenue!`.
+- Klient z `Accept-Language: pl` otrzyma `Witaj!`.
+- Klient z `Accept-Language: de` otrzyma `Welcome!` (domyślny język).
+
+### Obsługa Błędów
+
+Dostarczaj komunikaty o błędach w wielu językach:
+
+```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.",
+      pl: "Wystąpił nieoczekiwany błąd.",
+    }),
+    500
+  );
+});
+```
+
+---
+
+### Używanie Wariantów Językowych
+
+Określ tłumaczenia dla specyficznych wariantów językowych:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/greet", (c) => {
+  return c.text(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      pl: "Cześć!",
+    })
+  );
+});
+```
+
+---
+
+## Zaawansowane Tematy
+
+### Mechanizm Powrotny (Fallback)
+
+Jeśli preferowany język jest niedostępny, funkcja `t` powróci do domyślnego języka zdefiniowanego w konfiguracji:
+
+```typescript {5-6} fileName="intlayer.config.ts" codeFormat="typescript"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.POLISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+} satisfies IntlayerConfig;
+
+export default config;
+```
+
+---
+
+### Wymuszanie Trybu Ścisłego
+
+Skonfiguruj funkcję `t`, aby wymusić ścisłe przestrzeganie zadeklarowanych języków:
+
+| Tryb        | Zachowanie                                                                                              |
+| ----------- | ------------------------------------------------------------------------------------------------------- |
+| `strict`    | Wszystkie zadeklarowane języki muszą mieć tłumaczenia. Brakujące języki spowodują błędy.                |
+| `inclusive` | Zadeklarowane języki muszą mieć tłumaczenia. Brakujące języki wywołują ostrzeżenia, ale są akceptowane. |
+| `loose`     | Dowolny istniejący język jest akceptowany, nawet jeśli nie został zadeklarowany.                        |
+
+---
+
+### Integracja z TypeScript
+
+Funkcja `t` jest bezpieczna pod względem typów (type-safe) w przypadku użycia z TypeScript. Zdefiniuj bezpieczny obiekt tłumaczeń:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+import { type LanguageContent } from "hono-intlayer";
+
+const translations: LanguageContent<string> = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  pl: "Dzień dobry!",
+};
+
+app.get("/morning", (c) => {
+  return c.text(t(translations));
+});
+```
+
+---
+
+### Typowe Błędy i Rozwiązywanie Problemów
+
+| Problem                    | Przyczyna                                   | Rozwiązanie                                                      |
+| -------------------------- | ------------------------------------------- | ---------------------------------------------------------------- |
+| Funkcja `t` nie działa     | Middleware nie został załadowany            | Upewnij się, że `app.use("*", intlayer())` dodano przed trasami. |
+| Błąd brakujących tłumaczeń | Tryb ścisły włączony bez wszystkich języków | Dostarcz wszystkie wymagane tłumaczenia.                         |
+
+---
+
+## Podsumowanie
+
+Funkcja `t` jest potężnym narzędziem do internacjonalizacji backendu. Używając jej efektywnie, możesz stworzyć bardziej inkluzywną i przyjazną dla użytkownika aplikację dla globalnej publiczności. Więcej informacji na temat zaawansowanego użytkowania i szczegółowych opcji konfiguracji można znaleźć w [dokumentacji](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/configuration.md).