@intlayer/docs 5.5.8

package/de/introduction.md

@@ -0,0 +1,186 @@
+# Intlayer Dokumentation
+
+Willkommen bei der offiziellen Intlayer-Dokumentation! Hier finden Sie alles, was Sie benötigen, um Intlayer für Ihre Internationalisierungsanforderungen (i18n) zu integrieren, zu konfigurieren und zu beherrschen, egal ob Sie mit Next.js, React, Vite, Express oder einer anderen JavaScript-Umgebung arbeiten.
+
+## Einführung
+
+### Was ist Intlayer?
+
+**Intlayer** ist eine Internationalisierungsbibliothek, die speziell für JavaScript-Entwickler entwickelt wurde. Sie ermöglicht die Deklaration Ihrer Inhalte überall in Ihrem Code. Sie wandelt die Deklaration von mehrsprachigen Inhalten in strukturierte Wörterbücher um, die sich leicht in Ihren Code integrieren lassen. Mit TypeScript macht **Intlayer** Ihre Entwicklung robuster und effizienter.
+
+Intlayer bietet auch einen optionalen visuellen Editor, mit dem Sie Ihre Inhalte einfach bearbeiten und verwalten können. Dieser Editor ist besonders nützlich für Entwickler, die eine visuelle Oberfläche für die Inhaltsverwaltung bevorzugen, oder für Teams, die Inhalte generieren, ohne sich um den Code kümmern zu müssen.
+
+### Beispiel für die Nutzung
+
+```bash codeFormat="typescript"
+.
+└── Components
+    └── MyComponent
+        ├── index.content.ts
+        └── index.tsx
+```
+
+```bash codeFormat="commonjs"
+.
+└── Components
+    └── MyComponent
+        ├── index.content.cjs
+        └── index.mjs
+```
+
+```bash codeFormat="esm"
+.
+└── Components
+    └── MyComponent
+        ├── index.content.mjs
+        └── index.js
+```
+
+```tsx fileName="src/components/MyComponent/index.content.ts" contentDeclarationFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const componentContent = {
+  key: "component-key",
+  content: {
+    myTranslatedContent: t({
+      en: "Hello World",
+      fr: "Bonjour le monde",
+      es: "Hola Mundo",
+    }),
+  },
+} satisfies Dictionary;
+
+export default componentContent;
+```
+
+```javascript fileName="src/components/MyComponent/index.content.mjs" contentDeclarationFormat="esm"
+import { t } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const componentContent = {
+  key: "component-key",
+  content: {
+    myTranslatedContent: t({
+      en: "Hello World",
+      fr: "Bonjour le monde",
+      es: "Hola Mundo",
+    }),
+  },
+};
+
+export default componentContent;
+```
+
+```javascript fileName="src/components/MyComponent/index.content.cjs" contentDeclarationFormat="commonjs"
+const { t } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const componentContent = {
+  key: "component-key",
+  content: {
+    myTranslatedContent: t({
+      en: "Hello World",
+      fr: "Bonjour le monde",
+      es: "Hola Mundo",
+    }),
+  },
+};
+
+module.exports = componentContent;
+```
+
+```json fileName="src/components/MyComponent/index.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "component-key",
+  "content": {
+    "myTranslatedContent": {
+      "nodeType": "translation",
+      "translation": {
+        "en": "Hello World",
+        "fr": "Bonjour le monde",
+        "es": "Hola Mundo"
+      }
+    }
+  }
+}
+```
+
+```tsx fileName="src/components/MyComponent/index.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+export const MyComponent: FC = () => {
+  const { myTranslatedContent } = useIntlayer("component-key");
+
+  return <span>{myTranslatedContent}</span>;
+};
+```
+
+```jsx fileName="src/components/MyComponent/index.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const MyComponent = () => {
+  const { myTranslatedContent } = useIntlayer("component-key");
+
+  return <span>{myTranslatedContent}</span>;
+};
+```
+
+```jsx fileName="src/components/MyComponent/index.csx" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const MyComponent = () => {
+  const { myTranslatedContent } = useIntlayer("component-key");
+
+  return <span>{myTranslatedContent}</span>;
+};
+```
+
+## Hauptfunktionen
+
+Intlayer bietet eine Vielzahl von Funktionen, die auf die Anforderungen der modernen Webentwicklung zugeschnitten sind. Nachfolgend finden Sie die wichtigsten Funktionen mit Links zu detaillierten Dokumentationen:
+
+- **Unterstützung für Internationalisierung**: Erweitern Sie die globale Reichweite Ihrer Anwendung mit integrierter Unterstützung für Internationalisierung.
+- **Visueller Editor**: Verbessern Sie Ihren Entwicklungsworkflow mit Editor-Plugins, die für Intlayer entwickelt wurden. Schauen Sie sich den [Leitfaden für den visuellen Editor](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_visual_editor.md) an.
+- **Flexible Konfiguration**: Passen Sie Ihre Einrichtung mit umfangreichen Konfigurationsoptionen an, die im [Konfigurationsleitfaden](https://github.com/aymericzip/intlayer/blob/main/docs/de/configuration.md) beschrieben sind.
+- **Erweiterte CLI-Tools**: Verwalten Sie Ihre Projekte effizient mit der Befehlszeilenschnittstelle von Intlayer. Entdecken Sie die Möglichkeiten in der [CLI-Tools-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_cli.md).
+
+## Kernkonzepte
+
+### Wörterbuch
+
+Organisieren Sie Ihre mehrsprachigen Inhalte in der Nähe Ihres Codes, um alles konsistent und wartbar zu halten.
+
+- **[Erste Schritte](https://github.com/aymericzip/intlayer/blob/main/docs/de/dictionary/get_started.md)**  
+  Erfahren Sie die Grundlagen der Deklaration Ihrer Inhalte in Intlayer.
+
+- **[Übersetzung](https://github.com/aymericzip/intlayer/blob/main/docs/de/dictionary/translation.md)**  
+  Verstehen Sie, wie Übersetzungen generiert, gespeichert und in Ihrer Anwendung genutzt werden.
+
+- **[Aufzählung](https://github.com/aymericzip/intlayer/blob/main/docs/de/dictionary/enumeration.md)**  
+  Verwalten Sie wiederholte oder feste Datensätze in verschiedenen Sprachen einfach.
+
+- **[Funktionales Abrufen](https://github.com/aymericzip/intlayer/blob/main/docs/de/dictionary/function_fetching.md)**  
+  Erfahren Sie, wie Sie Inhalte dynamisch mit benutzerdefinierter Logik abrufen können, um den Workflow Ihres Projekts anzupassen.
+
+### Umgebungen & Integrationen
+
+Wir haben Intlayer mit Flexibilität im Hinterkopf entwickelt und bieten nahtlose Integration in beliebte Frameworks und Build-Tools:
+
+- **[Intlayer mit Next.js 15](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_nextjs_15.md)**
+- **[Intlayer mit Next.js 14 (App Router)](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_nextjs_14.md)**
+- **[Intlayer mit Next.js Page Router](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_nextjs_page_router.md)**
+- **[Intlayer mit React CRA](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_create_react_app.md)**
+- **[Intlayer mit Vite + React](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_vite+react.md)**
+- **[Intlayer mit Express](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_with_express.md)**
+
+Jeder Integrationsleitfaden enthält Best Practices für die Nutzung der Funktionen von Intlayer – wie **Server-Side Rendering**, **dynamisches Routing** oder **Client-Side Rendering** – damit Sie eine schnelle, SEO-freundliche und hoch skalierbare Anwendung beibehalten können.
+
+## Mitwirken & Feedback
+
+Wir schätzen die Kraft von Open Source und Community-getriebener Entwicklung. Wenn Sie Verbesserungen vorschlagen, einen neuen Leitfaden hinzufügen oder Probleme in unserer Dokumentation korrigieren möchten, können Sie gerne eine Pull-Anfrage einreichen oder ein Problem in unserem [GitHub-Repository](https://github.com/aymericzip/intlayer/blob/main/docs) eröffnen.
+
+**Bereit, Ihre Anwendung schneller und effizienter zu übersetzen?** Tauchen Sie in unsere Dokumentation ein, um Intlayer noch heute zu nutzen. Erleben Sie einen robusten, optimierten Ansatz für Internationalisierung, der Ihre Inhalte organisiert und Ihr Team produktiver macht.
+
+Viel Erfolg beim Übersetzen!

package/de/mcp_server.md

@@ -0,0 +1,150 @@
+# Intlayer MCP Server
+
+Der **Intlayer MCP (Model Context Protocol) Server** bietet KI-gestützte IDE-Unterstützung, die speziell für das Intlayer Ökosystem entwickelt wurde. Entworfen für moderne Entwicklerumgebungen wie **Cursor**, **GitHub Copilot workspace** und jede IDE, die das MCP-Protokoll unterstützt, bietet dieser Server kontextbezogene, Echtzeit-Unterstützung basierend auf der Konfiguration Ihres Projekts.
+
+## Warum den Intlayer MCP Server verwenden?
+
+Durch die Aktivierung des Intlayer MCP Servers in Ihrer IDE erhalten Sie:
+
+- **Intelligente CLI-Integration**
+  Greifen Sie direkt über Ihre IDE-Oberfläche auf Intlayer CLI-Befehle zu und führen Sie diese aus. Sehen Sie sich die vollständige Liste der Befehle und Optionen in der [Intlayer CLI-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_cli.md) an.
+
+- **Kontextbezogene Dokumentation**
+  Der MCP-Server lädt und stellt die Dokumentation bereit, die der Version von Intlayer entspricht, die Sie in Ihrem Projekt verwenden. Dies stellt sicher, dass Codevorschläge, Befehlsoptionen und Erklärungen stets aktuell und relevant sind.
+
+- **KI-gestützte Entwicklung**
+  Mit projektbezogenen Vorschlägen und Autovervollständigung kann der KI-Assistent Ihren Code erklären, CLI-Nutzung empfehlen oder vorschlagen, wie Sie bestimmte Funktionen von Intlayer basierend auf Ihren aktuellen Dateien verwenden können.
+
+- **Leichtgewichtig & Sofortige Einrichtung**
+  Keine Serverwartung oder aufwändige Installation erforderlich. Konfigurieren Sie einfach Ihre `.cursor/mcp.json` oder eine entsprechende MCP-Konfiguration und Sie sind startklar.
+
+---
+
+## Cursor einrichten
+
+Fügen Sie im Stammverzeichnis Ihres Projekts die folgende `.cursor/mcp.json`-Konfigurationsdatei hinzu:
+
+```json
+{
+  "mcpServers": {
+    "intlayer": {
+      "command": "npx",
+      "args": ["-y", "@intlayer/mcp"]
+    }
+  }
+}
+```
+
+Dies weist Ihre IDE an, den Intlayer MCP-Server mit `npx` zu starten, wodurch sichergestellt wird, dass immer die neueste verfügbare Version verwendet wird, es sei denn, Sie fixieren sie.
+
+---
+
+## VS Code einrichten
+
+Um den Intlayer MCP Server mit VS Code zu verwenden, müssen Sie ihn in Ihren Arbeitsbereichs- oder Benutzereinstellungen konfigurieren.
+
+### Arbeitsbereichskonfiguration
+
+Erstellen Sie eine `.vscode/mcp.json`-Datei im Stammverzeichnis Ihres Projekts:
+
+```json
+{
+  "servers": {
+    "intlayer": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@intlayer/mcp"]
+    }
+  }
+}
+```
+
+### Verwendung des MCP-Servers in VS Code
+
+1. **Agent-Modus aktivieren**: Öffnen Sie die Chat-Ansicht (⌃⌘I auf Mac, Ctrl+Alt+I auf Windows/Linux) und wählen Sie den **Agent**-Modus aus dem Dropdown-Menü.
+
+2. **Zugriff auf Tools**: Klicken Sie auf die Schaltfläche **Tools**, um verfügbare Intlayer-Tools anzuzeigen. Sie können bestimmte Tools nach Bedarf auswählen/abwählen.
+
+3. **Direkter Tool-Verweis**: Verweisen Sie direkt auf Tools in Ihren Eingabeaufforderungen, indem Sie `#` gefolgt vom Toolnamen eingeben.
+
+4. **Tool-Bestätigung**: Standardmäßig fragt VS Code nach einer Bestätigung, bevor Tools ausgeführt werden. Verwenden Sie die **Weiter**-Schaltflächenoptionen, um Tools automatisch für die aktuelle Sitzung, den Arbeitsbereich oder alle zukünftigen Aufrufe zu bestätigen.
+
+### Serververwaltung
+
+- Führen Sie **MCP: List Servers** aus der Befehlspalette aus, um konfigurierte Server anzuzeigen.
+- Starten, stoppen oder starten Sie den Intlayer MCP-Server nach Bedarf neu.
+- Sehen Sie sich Serverprotokolle zur Fehlerbehebung an, indem Sie den Server auswählen und **Show Output** wählen.
+
+Für detailliertere Informationen zur VS Code MCP-Integration siehe die [offizielle VS Code MCP-Dokumentation](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).
+
+---
+
+## Verwendung des MCP-Servers über CLI
+
+Sie können den Intlayer MCP-Server auch direkt über die Befehlszeile für Tests, Debugging oder die Integration mit anderen Tools ausführen.
+
+### Installation des MCP-Servers
+
+Installieren Sie zuerst das MCP-Server-Paket global oder verwenden Sie es über npx:
+
+```bash
+# Global installieren
+npm install -g @intlayer/mcp
+
+# Oder direkt mit npx verwenden (empfohlen)
+npx @intlayer/mcp
+```
+
+### Server starten
+
+Um den MCP-Server mit dem Inspector für Debugging und Tests zu starten:
+
+```bash
+# Mit dem integrierten Startbefehl
+npm run start
+
+# Oder direkt mit npx
+npx @modelcontextprotocol/inspector npx @intlayer/mcp
+```
+
+Dies startet den MCP-Server mit einer Inspector-Oberfläche, die Ihnen ermöglicht:
+
+- MCP-Protokollkommunikation zu testen
+- Serverantworten zu debuggen
+- Tool- und Ressourcenimplementierungen zu validieren
+- Serverleistung zu überwachen
+
+### Entwicklungseinsatz
+
+Für Entwicklungs- und Testzwecke können Sie den Server in verschiedenen Modi ausführen:
+
+```bash
+# Im Entwicklungsmodus erstellen und starten
+npm run dev
+
+# Mit benutzerdefinierter Konfiguration ausführen
+node dist/cjs/index.cjs
+
+# Serverfunktionalität testen
+npm test
+```
+
+Der Server stellt Intlayer-spezifische Tools und Ressourcen bereit, die von jedem MCP-kompatiblen Client genutzt werden können, nicht nur von Cursor oder anderen IDEs.
+
+---
+
+## Funktionsübersicht
+
+| Funktion                   | Beschreibung                                                                                        |
+| -------------------------- | --------------------------------------------------------------------------------------------------- |
+| CLI-Unterstützung          | Führen Sie `intlayer`-Befehle aus, erhalten Sie Nutzungshinweise und Argumente inline               |
+| Versionierte Dokumentation | Automatische Erkennung und Laden der Dokumentation, die Ihrer aktuellen Intlayer-Version entspricht |
+| Autovervollständigung      | Intelligente Befehls- und Konfigurationsvorschläge während der Eingabe                              |
+| Plugin-fähig               | Kompatibel mit IDEs und Tools, die den MCP-Standard unterstützen                                    |
+
+---
+
+## Nützliche Links
+
+- [Intlayer CLI-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/intlayer_cli.md)
+- [Intlayer GitHub-Repository](https://github.com/aymericzip/intlayer)

package/de/packages/@intlayer/api/index.md

@@ -0,0 +1,31 @@
+# @intlayer/api: NPM-Paket zur Interaktion mit der Intlayer-API
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/api`**-Paket ist ein SDK (Software Development Kit) zur Interaktion mit der Intlayer-API. Es bietet eine Reihe von Funktionen zur Überprüfung von Inhaltsdeklarationen, zur Interaktion mit Organisationen, Projekten und Benutzern usw.
+
+## Verwendung
+
+```ts
+import { intlayerAPI } from "@intlayer/api";
+
+intlayerAPI.user.getUser({
+  ids: ["user-id-1", "user-id-2"],
+});
+```
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/api
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/api
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/api
+```

package/de/packages/@intlayer/chokidar/index.md

@@ -0,0 +1,31 @@
+# @intlayer/chokidar: NPM-Paket zum Scannen und Erstellen von Intlayer-Deklarationsdateien in Wörterbücher
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/chokidar`**-Paket wird verwendet, um Intlayer-Deklarationsdateien in Wörterbücher zu scannen und zu erstellen, indem [chokidar](https://github.com/paulmillr/chokidar) und die [Intlayer-Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/de/configuration.md) verwendet werden.
+
+## Verwendung
+
+```ts
+import { watch, prepareIntlayer } from "@intlayer/chokidar";
+
+await prepareIntlayer(); // Intlayer-Wörterbücher erstellen
+
+watch({ persistent: true }); // Änderungen in den Konfigurationsdateien überwachen
+```
+
+## Installation
+
+Installieren Sie das erforderliche Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/chokidar
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/chokidar
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/chokidar
+```

package/de/packages/@intlayer/cli/index.md

@@ -0,0 +1,21 @@
+# @intlayer/cli: NPM-Paket zur Verwendung der von der intlayer CLI bereitgestellten Skripte
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/cli`**-Paket ist ein NPM-Paket, das verwendet wird, um die Skripte im Zusammenhang mit den intlayer-Befehlszeilenschnittstellen zu deklarieren. Es stellt die Einheitlichkeit aller intlayer CLI-Befehle sicher. Dieses Paket wird insbesondere von den Paketen [intlayer-cli](https://github.com/aymericzip/intlayer/blob/main/docs/de/packages/intlayer-cli/index.md) und [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/de/packages/intlayer/index.md) verwendet.
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/cli
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/cli
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/cli
+```

package/de/packages/@intlayer/config/index.md

@@ -0,0 +1,116 @@
+# @intlayer/config: NPM-Paket zur Abrufung der Intlayer-Konfiguration
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/config`**-Paket ist ein NPM-Paket, das es Ihnen ermöglicht, die Konfiguration von Intlayer abzurufen und die Umgebungsvariablen im Zusammenhang mit der aktuellen Umgebung zu definieren.
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/config
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/config
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/config
+```
+
+## Verwendung
+
+### Lesen der Intlayer-Konfiguration über das Dateisystem
+
+Beispiel:
+
+```ts
+import { getConfiguration, type IntlayerConfig } from "@intlayer/config";
+
+const config: IntlayerConfig = getConfiguration();
+
+console.log(config);
+// Ausgabe:
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+> Diese Funktion verwendet `fs`-Pakete und funktioniert nur auf der Serverseite.
+
+### Lesen der Intlayer-Konfiguration über Umgebungsvariablen
+
+Beispiel:
+
+```ts
+import { getConfiguration, type IntlayerConfig } from "@intlayer/config/client";
+
+const config: IntlayerConfig = getConfiguration({
+  env: "production",
+});
+
+console.log(config);
+// Ausgabe:
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+> Diese Funktion gibt nichts zurück, wenn die Umgebungsvariablen nicht definiert sind.
+
+### Definieren der Umgebungsvariablen
+
+1. Erstellen Sie eine Konfigurationsdatei.
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    /* ... */
+  },
+  middleware: {
+    /* ... */
+  },
+  content: {
+    /* ... */
+  },
+  editor: {
+    /* ... */
+  },
+};
+
+export default config;
+```
+
+> Siehe [Intlayer-Konfigurationsdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/configuration.md) für weitere Details.
+
+2. Definieren Sie die Umgebungsvariablen.
+
+```ts
+import { getConfiguration } from "@intlayer/config";
+
+const intlayerConfig = getConfiguration();
+
+// Formatieren Sie alle Konfigurationswerte als Umgebungsvariablen
+const env = formatEnvVariable();
+
+// Setzen Sie jede formatierte Umgebungsvariable in process.env
+Object.assign(process.env, env);
+```
+
+3. Importieren Sie die Konfigurationsdatei.
+
+```ts
+import { getConfiguration } from "@intlayer/config/client";
+
+const intlayerConfig = getConfiguration();
+```

package/de/packages/@intlayer/core/index.md

@@ -0,0 +1,25 @@
+# @intlayer/core: NPM-Paket mit den Kernfunktionen von Intlayer
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/core`**-Paket ist ein NPM-Paket, das die Kernfunktionen von Intlayer enthält, die von mehreren Paketen gemeinsam genutzt werden. Es umfasst insbesondere:
+
+- Übersetzungsfunktionen
+- Wörterbuchfunktionen
+- Hilfsfunktionen
+
+## Installation
+
+Installieren Sie das erforderliche Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/core
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/core
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/core
+```

package/de/packages/@intlayer/design-system/index.md

@@ -0,0 +1,21 @@
+# @intlayer/design-system: NPM-Paket, das die UI-Bibliothek von Intlayer enthält
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/design-system`**-Paket ist ein NPM-Paket, das das Designsystem von Intlayer enthält. Dieses Paket wird insbesondere vom [Intlayer-Editor](https://github.com/aymericzip/intlayer/tree/main/docs/de/packages/intlayer-editor/index.md), auf der [Website](https://intlayer.org) und im [Visuellen Editor / CMS](https://intlayer.org/dashboard) verwendet.
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/design-system
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/design-system
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/design-system
+```

package/de/packages/@intlayer/dictionary-entry/index.md

@@ -0,0 +1,21 @@
+# @intlayer/dictionary-entry: NPM-Paket zum Abrufen von Intlayer-Wörterbüchern
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, React und Express.js.
+
+Das **`@intlayer/dictionary-entry`**-Paket ist ein NPM-Paket, das nur den Einstiegspfad der Intlayer-Wörterbücher zurückgibt. Da die Dateisystemsuche vom Browser aus nicht möglich ist, ist es mit Bundlern wie Webpack oder Rollup nicht möglich, den Einstiegspfad der Wörterbücher abzurufen. Dieses Paket soll als Alias verwendet werden.
+
+## Installation
+
+Installieren Sie das erforderliche Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash packageManager="npm"
+npm install @intlayer/dictionary-entry
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/dictionary-entry
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/dictionary-entry
+```

package/de/packages/@intlayer/editor/index.md

@@ -0,0 +1,21 @@
+# @intlayer/editor: NPM-Paket, das Dienstprogramme zur Schnittstelle der Anwendung mit dem Intlayer-Editor und zur Manipulation von Wörterbüchern bereitstellt
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, Next.js und Express.js.
+
+Das **`intlayer-editor`**-Paket bietet Dienstprogramme, um die Anwendung mit dem Intlayer-Editor zu verbinden. Es enthält die API zur Interaktion mit dem Editor und Dienstprogramme zur Manipulation von Wörterbüchern. Dieses Paket ist plattformübergreifend.
+
+## Installation
+
+Installieren Sie das notwendige Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash
+npm install @intlayer/editor
+```
+
+```bash
+yarn add @intlayer/editor
+```
+
+```bash
+pnpm add @intlayer/editor
+```

package/de/packages/@intlayer/editor-react/index.md

@@ -0,0 +1,21 @@
+# @intlayer/editor-react: NPM-Paket, das React-States, Kontexte, Hooks und Komponenten bereitstellt, um mit dem Intlayer-Editor zu interagieren
+
+**Intlayer** ist eine Suite von Paketen, die speziell für JavaScript-Entwickler entwickelt wurde. Es ist kompatibel mit Frameworks wie React, Next.js und Express.js.
+
+Das **`@intlayer/editor-react`**-Paket stellt States, Kontexte, Hooks und Komponenten bereit, um mit dem Intlayer-Editor in einer React-Anwendung zu interagieren.
+
+## Installation
+
+Installieren Sie das erforderliche Paket mit Ihrem bevorzugten Paketmanager:
+
+```bash
+npm install @intlayer/editor-react
+```
+
+```bash
+yarn add @intlayer/editor-react
+```
+
+```bash
+pnpm add @intlayer/editor-react
+```