diff --git a/src/content/docs/de/config-reference/dashboard.mdx b/src/content/docs/de/config-reference/dashboard.mdx
new file mode 100644
index 00000000..50c82b8d
--- /dev/null
+++ b/src/content/docs/de/config-reference/dashboard.mdx
@@ -0,0 +1,227 @@
+---
+i18nReady: true
+title: Dashboard-Konfiguration
+description: Referenzseite für StudioCMSOptions dashboardConfig
+sidebar:
+ order: 6
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ dashboardEnabled: true,
+ dashboardRouteOverride: 'dashboard',
+ developerConfig: {},
+ faviconURL: '/favicon.svg',
+ inject404Route: true,
+ versionCheck: true,
+ AuthConfig: {},
+ },
+});
+```
+
+## `dashboardEnabled`
+
+`dashboardEnabled` ist ein boolescher Wert, mit dem du bestimmen kannst, ob das Dashboard aktiviert ist.
+
+- **Typ:** `boolean`
+- **Standard:** `true`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ dashboardEnabled: true, // STANDARD - Dadurch wird das Dashboard aktiviert.
+ }
+})
+```
+
+## `DashboardRouteOverride`
+
+`DashboardRouteOverride` ist eine Zeichenkette, der verwendet wird, um die Route für das Dashboard zu bestimmen.
+
+- **Typ:** `string`
+- **Standard:** `'dashboard'`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ dashboardRouteOverride: 'dashboard', // STANDARD - Damit wird die Dashboard-Route auf /dashboard gesetzt.
+ }
+})
+```
+
+## `developerConfig`
+
+`developerConfig` ist ein Objekt, das verwendet wird, um die Entwicklereinstellungen für das Dashboard zu konfigurieren.
+
+### Verwendung
+
+```ts twoslash {3-5} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ developerConfig: {
+ demoMode: false, // STANDARD - Dadurch wird der Demomodus deaktiviert.
+ },
+ }
+})
+```
+
+## `faviconURL`
+
+`faviconURL` ist eine Zeichenkette, die verwendet wird, um den Pfad zum Favicon für das Dashboard zu bestimmen.
+
+- **Typ:** `string`
+- **Standard:** `'/favicon.svg'`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ faviconURL: '/favicon.svg', // STANDARD - Damit wird das Favicon für das Dashboard festgelegt.
+ }
+})
+```
+
+## `inject404Route`
+
+`inject404Route` ist ein boolescher Wert, mit dem festgelegt wird, ob die 404-Route injiziert werden soll.
+
+- **Typ:** `boolean`
+- **Standard:** `true`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ inject404Route: true, // STANDARD - Dadurch wird die Route 404 injiziert.
+ }
+})
+```
+
+## `versionCheck`
+
+`versionCheck` ist ein boolescher Wert, mit dem festgelegt wird, ob die Versionsprüfung aktiviert werden soll.
+
+- **Typ:** `boolean`
+- **Standard:** `true`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ versionCheck: true, // STANDARD - Dies aktiviert Versionskontrolle.
+ }
+})
+```
+
+## `AuthConfig`
+
+`AuthConfig` ist ein Objekt, das verwendet wird, um die Authentifizierungseinstellungen für das Dashboard zu konfigurieren.
+
+### Verwendung
+
+```ts twoslash {3-5} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ AuthConfig: {
+ enabled: true, // STANDARD - Dies aktiviert Authentifizierung.
+ },
+ }
+})
+```
+
+### `providers`
+
+`providers` ist ein Objekt, das verwendet wird, um die Authentifizierungsanbieter für das Dashboard zu konfigurieren.
+
+- **Typ:** [`AuthProviders`](#authprovider)
+- **Standard:** `{}`
+
+#### Verwendung
+
+```ts twoslash {4-11} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ AuthConfig: {
+ providers: {
+ google: true,
+ github: true,
+ discord: true,
+ auth0: true,
+ usernameAndPassword: true,
+ usernameAndPasswordConfig: {},
+ },
+ },
+ },
+})
+```
+
+#### `usernameAndPasswordConfig`
+
+`usernameAndPasswordConfig` ist ein Objekt, mit dem du die Einstellungen für den Benutzernamen und das Passwort für das Dashboard konfigurierst.
+
+- **Typ:** `{ allowUserRegistration?: boolean }`
+- **Standard:** `{}`
+
+##### Verwendung
+
+```ts twoslash {5-8} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dashboardConfig: {
+ AuthConfig: {
+ providers: {
+ usernameAndPassword: true,
+ usernameAndPasswordConfig: {
+ allowUserRegistration: true, // STANDARD - Dies ermöglicht die Registrierung von Nutzern.
+ },
+ },
+ },
+ },
+})
+```
+
+###### `AuthProvider`
+
+```ts
+type AuthProviders: {
+ github?: boolean | undefined;
+ discord?: boolean | undefined;
+ google?: boolean | undefined;
+ auth0?: boolean | undefined;
+ usernameAndPassword?: boolean | undefined;
+ usernameAndPasswordConfig?: {
+ allowUserRegistration?: boolean | undefined;
+ } | undefined;
+} | undefined
+```
\ No newline at end of file
diff --git a/src/content/docs/de/config-reference/default-frontend-config.mdx b/src/content/docs/de/config-reference/default-frontend-config.mdx
new file mode 100644
index 00000000..7900fd00
--- /dev/null
+++ b/src/content/docs/de/config-reference/default-frontend-config.mdx
@@ -0,0 +1,120 @@
+---
+i18nReady: true
+title: Standard-Frontend-Konfiguration
+description: Referenzseite für StudioCMSOptions defaultFrontEndConfig
+sidebar:
+ order: 5
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ defaultFrontEndConfig: {
+ favicon: '/favicon.svg',
+ htmlDefaultLanguage: 'en',
+ htmlDefaultHead: [],
+ injectQuickActionsMenu: true,
+ },
+});
+```
+
+## `favicon`
+
+`favicon` ist eine Zeichenkette, die verwendet wird, um den Pfad zum Favicon für die Website zu bestimmen.
+
+- **Typ:** `string`
+- **Standard:** `'/favicon.svg'`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ defaultFrontEndConfig: {
+ favicon: '/favicon.svg', // STANDARD - Hier wird das Standard-Favicon verwendet.
+ }
+})
+```
+
+## `htmlDefaultLanguage`
+
+`htmlDefaultLanguage` ist eine Zeichenkette, die verwendet wird, um die Standardsprache für die Website festzulegen.
+
+- **Typ:** `string`
+- **Standard:** `'en'`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ defaultFrontEndConfig: {
+ htmlDefaultLanguage: 'en', // STANDARD - Dabei wird die Standardsprache verwendet.
+ }
+})
+```
+
+## `htmlDefaultHead`
+
+**Typ:** [`HeadConfig[]`](#headconfig)
+
+Füge benutzerdefinierte Tags zum `
` deiner Starlight-Website hinzu.
+Das kann nützlich sein, um Analysen und andere Skripte und Ressourcen von Drittanbietern hinzuzufügen.
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ defaultFrontEndConfig: {
+ htmlDefaultHead: [
+ // Beispiel: Fathom analytics script tag hinzufügen.
+ {
+ tag: 'script',
+ attrs: {
+ src: 'https://cdn.usefathom.com/script.js',
+ 'data-site': 'MY-FATHOM-ID',
+ defer: true,
+ },
+ },
+ ],
+ },
+});
+```
+
+Einträge in `head` werden direkt in HTML-Elemente umgewandelt und durchlaufen nicht die [Skript](https://docs.astro.build/en/guides/client-side-scripts/#script-processing)- oder [Style](https://docs.astro.build/en/guides/styling/#styling-in-astro)-Verarbeitung von Astro.
+
+#### `HeadConfig`
+
+```ts
+interface HeadConfig {
+ tag: string;
+ attrs?: Record;
+ content?: string;
+}
+```
+
+## `injectQuickActionsMenu`
+
+**Typ:** `boolean`
+**Standard:** `true`
+
+Fügt eine Benutzeroberfläche für schnelle Aktionen in der rechten unteren Ecke der Hauptseite ein, mit der du schnell zur StudioCMS-Verwaltungsoberfläche navigieren kannst.
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ defaultFrontEndConfig: {
+ injectQuickActionsMenu: true, // STANDARD - Dadurch wird das Schnellaktionsmenü eingefügt.
+ }
+})
+```
\ No newline at end of file
diff --git a/src/content/docs/de/config-reference/image-service.mdx b/src/content/docs/de/config-reference/image-service.mdx
new file mode 100644
index 00000000..d66579aa
--- /dev/null
+++ b/src/content/docs/de/config-reference/image-service.mdx
@@ -0,0 +1,28 @@
+---
+i18nReady: true
+title: Bilderdienst
+description: Referenzseite für StudioCMSOptions imageService
+sidebar:
+ order: 4
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ imageService: {
+ cdnPlugin: 'cloudinary-js'
+ },
+});
+```
+
+## `cdnPlugin`
+
+`cdnPlugin` ist eine Aufzählung, mit der festgelegt wird, welches CDN-Plugin für Bilder verwendet werden soll, wenn es aktiviert ist.
+
+- **Typ:** `'cloudinary-js'` | `undefined`
+- **Standard:** `undefined`
\ No newline at end of file
diff --git a/src/content/docs/de/config-reference/included-integrations.mdx b/src/content/docs/de/config-reference/included-integrations.mdx
new file mode 100644
index 00000000..de5fb2cf
--- /dev/null
+++ b/src/content/docs/de/config-reference/included-integrations.mdx
@@ -0,0 +1,56 @@
+---
+i18nReady: true
+title: Inklusive Integrationen
+description: Referenzseite für StudioCMSOptions IncludedIntegrations
+sidebar:
+ order: 7
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ includedIntegrations: {
+ robotsTXT: true
+ },
+});
+```
+
+## `robotsTXT`
+
+`robotsTXT` ist ein boolescher Wert oder ein Objekt, das verwendet wird, um festzustellen, ob die robots.txt-Datei aktiviert ist.
+
+- **Typ:** `boolean` | [`RobotsConfig`](#robotsconfig) | `undefined`
+- **Standard:** `true`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ includedIntegrations: {
+ robotsTXT: true, // STANDARD - Dies aktiviert die robots.txt-Datei.
+ }
+})
+```
+
+##### `RobotsConfig`
+
+```ts
+interface RobotsConfig {
+ host?: boolean | string;
+ sitemap?: boolean | string | string[];
+ policy?: {
+ userAgent?: string;
+ disallow?: string | string[];
+ allow?: string | string[];
+ crawlDelay?: number;
+ cleanParam?: string | string[];
+ }[] | undefined;
+}
+```
\ No newline at end of file
diff --git a/src/content/docs/de/config-reference/index.mdx b/src/content/docs/de/config-reference/index.mdx
new file mode 100644
index 00000000..fc3484a8
--- /dev/null
+++ b/src/content/docs/de/config-reference/index.mdx
@@ -0,0 +1,187 @@
+---
+i18nReady: true
+title: StudioCMSOptions
+description: Referenzseite für StudioCMSOptions
+sidebar:
+ order: 1
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+// Standardwerte angezeigt
+export default defineStudioCMSConfig({
+ dbStartPage: true,
+ dateLocale: 'en-us',
+ verbose: false,
+ plugins: [],
+ componentRegistry: {},
+ overrides: {},
+ imageService: {},
+ defaultFrontEndConfig: {},
+ dashboardConfig: {},
+ includedIntegrations: {},
+ dateTimeFormat: {},
+ sdk: {},
+ pageTypeOptions: {}
+});
+```
+
+## `dbStartPage`
+
+Projektinitialisierungsseite - Wird bei der Ersteinrichtung verwendet, um deine Datenbankkonfiguration zu erstellen.
+
+- **Typ:** `boolean`
+- **Standard:** `true`
+
+### Verwendung
+
+```ts twoslash {2} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dbStartPage: true, // STANDARD - Dies fügt eine Startseite ein, um deine DB-Daten einzurichten.
+})
+```
+
+## `dateLocale`
+
+`dateLocale` ist eine Zeichenkette, der verwendet wird, um das Gebietsschema für die Datumsformatierung zu bestimmen.
+
+- **Typ:** `string`
+- **Standard:** `'en-us'`
+
+### Verwendung
+
+```ts twoslash {2} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dateLocale: 'en-us', // STANDARD - Hier wird das Gebietsschema für die Datumsformatierung festgelegt.
+})
+```
+
+## `verbose`
+
+`verbose` ist ein boolescher Wert, mit dem du die ausführliche Protokollierung aktivieren oder deaktivieren kannst.
+
+- **Typ:** `boolean`
+- **Standard:** `false`
+
+### Verwendung
+
+```ts twoslash {2} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ verbose: false, // STANDARD - Dies setzt die ausführliche Protokollierung auf false.
+})
+```
+
+## `plugins`
+
+`plugins` ist ein Array, mit dem festgelegt wird, welche Plugins geladen werden sollen.
+
+- **Typ:** `StudioCMSPlugin[]`
+- **Standard:** `[]`
+
+### Verwendung
+
+```ts twoslash {1, 3-5} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+import blog from '@studiocms/blog';
+export default defineStudioCMSConfig({
+ plugins: [
+ blog(),
+ ],
+})
+```
+
+## `componentRegistry`
+
+`componentRegistry` ist ein Objekt, das zur Registrierung von Komponenten verwendet wird.
+
+- **Typ:** `Record`
+- **Standard:** `{}`
+
+### Verwendung
+
+```ts twoslash {2-4} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ componentRegistry: {
+ 'my-component': 'src/components/MyComponent.astro',
+ },
+})
+```
+
+## `dateTimeFormat`
+
+`dateTimeFormat` ist ein Objekt, mit dem du das Datums- und Zeitformat konfigurieren kannst.
+
+- **Typ:** `Intl.DateTimeFormatOptions`
+- **Standard:** `{}`
+
+### Verwendung
+
+```ts twoslash {2-6} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ dateTimeFormat: {
+ year: "numeric",
+ month: "short",
+ day: "numeric"
+ },
+})
+```
+
+## `overrides`
+
+`overrides` ist ein Objekt, mit dem die Standardkonfiguration überschrieben werden kann.
+
+[Siehe `overrides` für alle Optionen][overrides]
+
+## `imageService`
+
+`imageService` ist ein Objekt, das zur Konfiguration des Bilddienstes verwendet wird.
+
+[Siehe `imageService` für alle Optionen][image-service]
+
+## `defaultFrontEndConfig`
+
+`defaultFrontEndConfig` ist ein Objekt, mit dem das Standard-Frontend konfiguriert wird.
+
+[Siehe `defaultFrontEndConfig` für alle Optionen][default-frontend-config]
+
+## `dashboardConfig`
+
+`dashboardConfig` ist ein Objekt, mit dem das Dashboard konfiguriert werden kann.
+
+[Siehe `dashboardConfig` für alle Optionen][dashboard]
+
+## `includedIntegrations`
+
+`includedIntegrations` ist ein Objekt, das verwendet wird, um zu konfigurieren, welche Integrationen einbezogen werden sollen.
+
+[Siehe `includedIntegrations` für alle Optionen][included-integrations]
+
+## `sdk`
+
+`sdk` ist ein Objekt, das zur Konfiguration des SDKs verwendet wird.
+
+[Siehe `sdk` für alle Optionen][sdk]
+
+{/* Links */}
+[overrides]: /de/config-reference/overrides/
+[image-service]: /de/config-reference/image-service/
+[default-frontend-config]: /de/config-reference/default-frontend-config/
+[dashboard]: /de/config-reference/dashboard/
+[included-integrations]: /de/config-reference/included-integrations/
+[sdk]: /de/config-reference/sdk/
\ No newline at end of file
diff --git a/src/content/docs/de/config-reference/overrides.mdx b/src/content/docs/de/config-reference/overrides.mdx
new file mode 100644
index 00000000..f38ef339
--- /dev/null
+++ b/src/content/docs/de/config-reference/overrides.mdx
@@ -0,0 +1,77 @@
+---
+i18nReady: true
+title: Überschreibungen
+description: Referenzseite für StudioCMSOptions overrides
+sidebar:
+ order: 2
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ overrides: {
+ CustomImageOverride: 'src/components/CustomImage.astro',
+ FormattedDateOverride: 'src/components/FormattedDate.astro',
+ },
+});
+```
+
+## `CustomImageOverride`
+
+`CustomImageOverride` ist eine Zeichenkette, der verwendet wird, um den Pfad zur benutzerdefinierten Bildkomponente zu bestimmen.
+
+- **Typ:** `string`
+- **Standard:** `undefined`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ overrides: {
+ CustomImageOverride: 'src/components/CustomImage.astro',
+ },
+})
+```
+
+## `FormattedDateOverride`
+
+`FormattedDateOverride` ist eine Zeichenkette, der verwendet wird, um den Pfad zur benutzerdefinierten Datumskomponente zu bestimmen.
+
+- **Typ:** `string`
+- **Standard:** `undefined`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ overrides: {
+ FormattedDateOverride: 'src/components/FormattedDate.astro',
+ },
+})
+```
+
+### Standard-Komponente
+
+```astro title="FormattedDate.astro"
+---
+import config from 'studiocms:config';
+
+interface Props {
+ date: Date;
+}
+
+const datetime = Astro.props.date.toISOString();
+const formattedDate = Astro.props.date.toLocaleDateString(config.dateLocale, config.dateTimeFormat);
+---
+
+
+```
\ No newline at end of file
diff --git a/src/content/docs/de/config-reference/sdk.mdx b/src/content/docs/de/config-reference/sdk.mdx
new file mode 100644
index 00000000..cb585478
--- /dev/null
+++ b/src/content/docs/de/config-reference/sdk.mdx
@@ -0,0 +1,43 @@
+---
+i18nReady: true
+title: SDK
+description: Referenzseite für StudioCMSOptions sdk
+sidebar:
+ order: 8
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS Integration Konfigurationsoptionen Schema Referenz.
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ sdk: {
+ cacheConfig: {},
+ },
+});
+```
+
+## `cacheConfig`
+
+`cacheConfig` ist ein Objekt, das verwendet wird, um den Cache für das SDK zu konfigurieren.
+
+- **Typ:** `boolean` | `{ lifetime?: string | undefined; }` | `undefined`
+- **Standard:** `{}`
+
+### Verwendung
+
+```ts twoslash {3} title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+// ---cut---
+export default defineStudioCMSConfig({
+ sdk: {
+ // STANDARD - Hier wird die Standard-Cache-Konfiguration verwendet.
+ cacheConfig: {
+ lifetime: '5m',
+ },
+ }
+})
+```
\ No newline at end of file
diff --git a/src/content/docs/de/contributing/code-contributions.mdx b/src/content/docs/de/contributing/code-contributions.mdx
new file mode 100644
index 00000000..9e12e093
--- /dev/null
+++ b/src/content/docs/de/contributing/code-contributions.mdx
@@ -0,0 +1,63 @@
+---
+i18nReady: true
+title: Code-Beiträge
+description: Erfahre, wie du zu StudioCMS beitragen kannst
+sidebar:
+ order: 2
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+In diesem Leitfaden erhältst du einen Überblick über den Beitrags-Workflow vom Eröffnen eines Problems über das Erstellen eines PRs bis hin zum Überprüfen und Zusammenführen des PRs.
+
+Wenn du Code zu diesem Projekt beitragen möchtest, befolge bitte die folgenden Schritte:
+
+## Löse ein Problem
+
+Durchsuche unsere [bestehenden Issues](https://github.com/withstudiocms/studiocms/issues), um eine zu finden, die dich interessiert. Du kannst die Suche eingrenzen, indem du `labels` als Filter verwendest. Wenn du ein Problem findest, an dem du arbeiten möchtest, kannst du gerne einen PR mit einer Lösung eröffnen.
+
+## Änderungen vornehmen
+
+
+1. Forke das Repository.
+ - GitHub Desktop verwenden:
+ - [Erste Schritte mit GitHub Desktop](https://docs.github.com/de/desktop/overview/getting-started-with-github-desktop) führt dich durch die Einrichtung von Desktop.
+ - Sobald der Desktop eingerichtet ist, kannst du ihn benutzen, um [das Repo zu forken](https://docs.github.com/de/desktop/adding-and-cloning-repositories/cloning-and-forking-repositories-from-github-desktop)!
+
+ - Benutze die Kommandozeile:
+ - [Forke das Repo](https://docs.github.com/de/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo#fork-an-example-repository), damit du deine Änderungen vornehmen kannst, ohne das ursprüngliche Projekt zu beeinflussen, bis du sie zusammenführen kannst.
+
+2. Installiere oder aktualisiere **Node.js** und **pnpm**, auf die Versionen, die in [`.prototools`](https://github.com/withstudiocms/studiocms/blob/main/.prototools) definiert sind.
+
+3. Erstelle einen Branch und beginne mit deinen Änderungen!
+
+4. Schreibe Tests für deine Änderungen, falls zutreffend.
+
+5. Aktualisiere die Dokumentation, falls nötig.
+
+
+## Commite deine Änderungen
+
+Commite die Änderungen, wenn du mit ihnen zufrieden bist.
+
+## Pull Request
+
+Wenn du mit den Änderungen fertig bist, erstelle einen Pull Request, auch PR genannt.
+- FFülle die Vorlage „Bereit zur Überprüfung“ aus, damit wir deinen PR überprüfen können. Diese Vorlage hilft den Prüfern, deine Änderungen und den Zweck deines Pull Requests zu verstehen.
+- Vergiss nicht, [PR zum Issue](https://docs.github.com/de/issues/tracking-your-work-with-issues/using-issues/linking-a-pull-request-to-an-issue) zu verknüpfen, wenn du eine Aufgabe löst.
+- Aktiviere das Kontrollkästchen [Erlaube Bearbeitungen der Maintainer](https://docs.github.com/de/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork), damit der Branch für eine Zusammenführung aktualisiert werden kann.
+Sobald du deinen PR eingereicht hast, wird ein Mitglied des Docs-Teams deinen Vorschlag prüfen. Wir können Fragen stellen oder zusätzliche Informationen anfordern.
+- Wir können um Änderungen bitten, bevor ein PR zusammengeführt werden kann, entweder mit [Änderungsvorschlägen](https://docs.github.com/de/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork) oder mit Pull Request-Kommentaren. Du kannst die vorgeschlagenen Änderungen direkt über die Benutzeroberfläche übernehmen. Du kannst alle anderen Änderungen in deinem Fork vornehmen und sie dann in deinen Branch übertragen.
+- Wenn du deinen PR aktualisierst und Änderungen vornimmst, markiere jede Unterhaltung als [gelöst](https://docs.github.com/de/pull-requests/collaborating-with-pull-requests/reviewing-changes-in-pull-requests/commenting-on-a-pull-request#unterhaltungen-auflösen).
+- Wenn du auf Probleme beim Zusammenführen stößt, schau dir diese [Git-Anleitung](https://github.com/skills/resolve-merge-conflicts) an, welche dir hilft, Konflikte beim Zusammenführen und andere Probleme zu lösen.
+
+## Dein PR wird zusammengeführt!
+
+Herzlichen Glückwunsch! Das StudioCMS-Team dankt dir. Dein Beitrag wird Teil der nächsten Version sein.
+
+Jetzt, wo du Teil der StudioCMS-Community bist, kannst du uns helfen, andere PRs zu überprüfen, Fragen zu beantworten und anderen Autoren zu helfen. Wenn du es noch nicht getan hast, melde dich in unserem [Discord](https://chat.studiocms.dev) an, um dich mit anderen Autoren und dem StudioCMS-Team auszutauschen.
+
+Oh, und du wirst dein Gesicht in der [Liste der Mitwirkenden][contributors] sehen! 🎉
+
+{/* Links */}
+[contributors]: /de/contributing/getting-started/#unsere-mitwirkenden
\ No newline at end of file
diff --git a/src/content/docs/de/contributing/getting-started.mdx b/src/content/docs/de/contributing/getting-started.mdx
new file mode 100644
index 00000000..38d790e4
--- /dev/null
+++ b/src/content/docs/de/contributing/getting-started.mdx
@@ -0,0 +1,27 @@
+---
+i18nReady: true
+title: Erste Schritte
+description: Erfahre, wie du zu StudioCMS beitragen kannst
+sidebar:
+ order: 1
+---
+import ContributorList from '~/components/ContributorList.astro';
+
+Danke, dass du deine Zeit in unser Projekt investierst!
+
+Lies unseren [Verhaltenskodex](https://github.com/withstudiocms/studiocms?tab=coc-ov-file#code-of-conduct-), um unsere Gemeinschaft ansprechbar und respektabel zu halten.
+
+Wir freuen uns über Beiträge aus der Community! Egal, ob es sich um Bug-Reports, Feature Requests oder Code-Beiträge handelt, wir freuen uns über deine Hilfe, dieses Projekt besser zu machen. Wie du dich in unserer Codebasis zurechtfindest, erfährst du im Abschnitt [Wie es funktioniert][how-it-works].
+
+## Unsere Mitwirkenden
+
+Unser Projekt existiert dank all der Menschen, die dazu beitragen. [Tritt uns auf GitHub bei](https://github.com/withstudiocms/studiocms) und trage dich in die Liste ein!
+
+
+
+## Fehlerberichte und Feature Requests
+
+Wenn du auf einen Fehler stößt oder eine neue Funktion vorschlagen möchtest, eröffne bitte einen Fehler in unserem [GitHub Repository](https://github.com/withstudiocms/studiocms). Wenn du ein neues Problem erstellst, gib bitte so viele Details wie möglich an, einschließlich der Schritte zur Reproduktion des Problems (bei Fehlern) und einer klaren Beschreibung der vorgeschlagenen Funktion.
+
+{/* Links */}
+[how-it-works]: /de/how-it-works/
\ No newline at end of file
diff --git a/src/content/docs/de/contributing/translations.mdx b/src/content/docs/de/contributing/translations.mdx
new file mode 100644
index 00000000..018792d6
--- /dev/null
+++ b/src/content/docs/de/contributing/translations.mdx
@@ -0,0 +1,34 @@
+---
+i18nReady: true
+title: Übersetzungen
+description: Erfahre, wie du bei der Übersetzung von StudioCMS helfen kannst
+sidebar:
+ order: 2
+ badge:
+ text: Demnächst
+ variant: note
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+StudioCMS ist ein globales Projekt, und wir wollen es für alle zugänglich machen. Wenn du mehrere Sprachen fließend beherrschst, kannst du uns helfen, StudioCMS in deine Sprache zu übersetzen.
+
+## Dashboard-i18n
+
+Aktueller Stand der Übersetzung
+
+
+
+Besuche [unser i18n-Dashboard](https://i18n.studiocms.dev), um die Übersetzung von StudioCMS in deine Sprache zu unterstützen. Wenn deine Sprache nicht aufgeführt ist, kannst du sie im Dashboard hinzufügen.
+
+Wenn du die Übersetzungen lieber direkt in das Repository einbringen möchtest, werden sie im Verzeichnis [`packages/studiocms/src/lib/i18n/translations`](https://github.com/withstudiocms/studiocms/tree/main/packages/studiocms/src/lib/i18n/translations/) gespeichert. Die englischen Übersetzungen findest du in der Datei [`en-us.json`](https://github.com/withstudiocms/studiocms/blob/main/packages/studiocms/src/lib/i18n/translations/en-us.json).
+
+
+StudioCMS nutzt [Crowdin](https://crowdin.com/) für die Verwaltung von Übersetzungen auf GitHub. Wenn du Crowdin noch nicht kennst, findest du auf der Website von Crowdin den [Leitfaden für Übersetzer](https://support.crowdin.com/for-translators/).
+
+
+Sobald die Übersetzungen hinzugefügt wurden, werden sie zur [StudioCMS i18n-Konfiguration](https://github.com/withstudiocms/studiocms/blob/main/packages/studiocms/src/lib/i18n/index.ts#L8) hinzugefügt und sind in der nächsten Version verfügbar.
+
+## Dokumentation
+
+**Bald!** Wir arbeiten daran, die StudioCMS-Dokumentation zu übersetzen. Wenn du daran interessiert bist, uns dabei zu helfen, melde dich bitte bei uns auf [Discord](https://chat.studiocms.dev)
diff --git a/src/content/docs/de/how-it-works/cli.mdx b/src/content/docs/de/how-it-works/cli.mdx
new file mode 100644
index 00000000..91f1efc4
--- /dev/null
+++ b/src/content/docs/de/how-it-works/cli.mdx
@@ -0,0 +1,217 @@
+---
+i18nReady: true
+title: "Das CLI"
+description: "Erfahre mehr über die StudioCMS CLIs und wie du sie benutzt."
+sidebar:
+ order: 2
+---
+
+import { Tabs, TabItem } from '@astrojs/starlight/components';
+import ReadMore from '~/components/ReadMore.astro';
+
+# Einführung
+
+Die StudioCMS CLIs sind Dienstprogramme, mit denen du schnell neue StudioCMS-Projekte einrichten und nützliche Dienstprogramme für StudioCMS bereitstellen kannst.
+There is two different CLIs that are part of the StudioCMS ecosystem:
+
+- **`create-studiocms`**: Das StudioCMS-Projektgerüst CLI.
+- **`studiocms`**: Das StudioCMS Dienstprogramm CLI.
+
+Im Folgenden findest du eine Übersicht über die StudioCMS CLI und ihre Komponenten.
+
+## `create-studiocms`
+
+### Installation
+
+
+
+ ```sh
+ npm create studiocms@latest
+ ```
+
+
+ ```sh
+ pnpm create studiocms
+ ```
+
+
+ ```sh
+ yarn create studiocms
+ ```
+
+
+
+`create-studiocms` läuft automatisch im _interaktiven_ Modus, aber du kannst deinen Projektnamen und deine Vorlage auch mit Kommandozeilenargumenten angeben.
+
+
+
+ ```sh
+ npm create studiocms@latest -- --template studiocms/basics --project-name my-studiocms-project
+ ```
+
+
+ ```sh
+ pnpm create studiocms --template studiocms/basics --project-name my-studiocms-project
+ ```
+
+
+ ```sh
+ yarn create studiocms --template studiocms/basics --project-name my-studiocms-project
+ ```
+
+
+
+[Eine vollständige Liste][templates] findest du auf GitHub.
+
+Wenn du `--template` verwendest, durchsucht das CLI das Vorlagen-Repository nach allen Ordnern. Die Vorlage `studiocms/basics` verweist zum Beispiel auf das Projekt `basics` im Ordner `studiocms` im Stammverzeichnis des Repositorys.
+
+### Vollständige CLI Optionen und Befehle
+
+#### Haupteinstiegspunkt
+
+```log
+Usage: create-studiocms [options] [command]
+
+Options:
+ -V, --version Output the current version of the CLI Toolkit.
+ -h, --help display help for command
+ --color force color output
+ --no-color disable color output
+
+Commands:
+ get-turso Get the latest version of Turso.
+ help Show help for command
+ interactive* Start the interactive CLI.
+
+ * Indicates the default command that is run when calling this CLI.
+```
+
+#### `get-turso`
+
+Du kannst die neueste Version von Turso herunterladen und installieren, indem du das Skript aus
+Turso's [Dokumentation](https://docs.turso.tech/cli/installation).
+
+:::note
+Windows erfordert die Verwendung von WSL wie bei Turso
+:::
+
+```log
+Usage: getTurso [options]
+
+Turso CLI Installer
+
+Options:
+ -h, --help display help for command
+```
+
+#### Interaktiv (Standardbefehl)
+
+```log
+Usage: create-studiocms interactive [options]
+
+Start the interactive CLI. Powered by [clack](https://clack.cc).
+
+This command will open an interactive CLI prompt to guide you through
+the process of creating a new StudioCMS(or StudioCMS Ecosystem package)
+project using one of the available templates.
+
+Options:
+ -t, --template The template to use.
+ -r, --template-ref The template reference to use.
+ -p, --project-name The name of the project.
+ -i, --install Install dependencies.
+ -g, --git Initialize a git repository.
+ -y, --yes Skip all prompts and use default values.
+ -n, --no Skip all prompts and use default values.
+ -q, --skip-banners Skip all banners and messages.
+ -d, --dry-run Do not perform any actions.
+ -h, --help display help for command
+ --do-not-install Do not install dependencies.
+ --do-not-init-git Do not initializing a git repository.
+```
+
+## `studiocms`
+
+### Vollständige CLI Optionen und Befehle
+
+#### Haupteinstiegspunkt
+
+```log
+Usage: studiocms [options] [command]
+
+Options:
+ -V, --version Output the current version of the CLI Toolkit.
+ -h, --help display help for command
+ --color force color output
+ --no-color disable color output
+
+Commands:
+ get-turso Get the latest version of Turso.
+ help Show help for command
+ init Initialization Tools.
+```
+
+#### `get-turso`
+
+Lädt die neueste Version von Turso herunter und installiert sie mit dem Skript aus
+Turso's [Dokumentation](https://docs.turso.tech/cli/installation)
+
+:::note
+Windows erfordert die Verwendung von WSL wie bei Turso
+:::
+
+```log
+Usage: getTurso [options]
+
+Turso CLI Installer
+
+Options:
+ -h, --help display help for command
+```
+
+#### `init`
+
+```log
+Usage: studiocms init [options]
+
+Initialize the StudioCMS project after new installation.
+
+Options:
+ -d, --dry-run Dry run mode
+ --skip-banners Skip all banners
+ --debug Enable debug mode
+ -h, --help Display help for command
+```
+
+Der init-Befehl bietet eine interaktive Einrichtungsmöglichkeit, die dir hilft:
+
+1. Richte deine Umgebungsdatei (.env) mit den folgenden Optionen ein:
+ - eine Beispiel-`.env`-Vorlage zu verwenden
+ - den interaktiven `.env`-Builder zu verwenden, mit dem du:
+ - Eine neue Turso-Datenbank einrichten (wenn nicht unter Windows)
+ - OAuth-Anbieter konfigurieren (GitHub, Discord, Google, Auth0)
+ - Verschlüsselungsschlüssel und andere erforderliche Variablen setzen
+ - Die Erstellung von Umgebungsdateien überspringen
+
+2. Der Befehl beinhaltet die automatische Turso CLI-Installation und die Authentifizierung, falls dies beim Einrichten einer Datenbank erforderlich ist.
+
+## Umgebungsvariablen
+
+Für StudioCMS müssen mehrere Umgebungsvariablen konfiguriert werden. Hier sind die wichtigsten Variablen:
+
+```dotenv
+# Datenbank-Konfiguration
+ASTRO_DB_REMOTE_URL=libsql://your-database.turso.io
+ASTRO_DB_APP_TOKEN=your-token
+
+# Auth-Konfiguration
+CMS_ENCRYPTION_KEY="..." # Generated with openssl rand --base64 16
+```
+
+Eine vollständige Liste der Umgebungsvariablen findest du in der [Dokumentation Umgebungsvariablen][environment-variables].
+
+Du kannst diese Variablen mit dem interaktiven Environment Builder des Befehls `studiocms init` einrichten.
+
+
+[templates]: https://github.com/withstudiocms/templates
+[environment-variables]: /de/start-here/environment-variables/
\ No newline at end of file
diff --git a/src/content/docs/de/how-it-works/index.mdx b/src/content/docs/de/how-it-works/index.mdx
new file mode 100644
index 00000000..90bea73f
--- /dev/null
+++ b/src/content/docs/de/how-it-works/index.mdx
@@ -0,0 +1,133 @@
+---
+i18nReady: true
+title: "Die Integration"
+description: "Erfahre, wie StudioCMS dir hilft, deine Inhalte zu verwalten und bereitzustellen, indem du eine umfassende Übersicht über die grundlegenden Komponenten des Systems erhältst."
+sidebar:
+ order: 1
+---
+
+# Einführung
+
+StudioCMS ist ein leistungsstarkes CMS für Astro, mit dem du deine Inhalte mit [Astro DB](https://docs.astro.build/de/guides/astro-db/) verwalten und bereitstellen kannst. Es ist benutzerfreundlich und flexibel genug, um alle Arten von Inhalten zu verwalten.
+
+Auch die Erweiterung von StudioCMS ist einfach! Du kannst deine eigenen Plugins erstellen, um StudioCMS neue Funktionen hinzuzufügen.
+
+Die StudioCMS-Integration ist die Basis für das gesamte StudioCMS-Ökosystem. Sie bietet eine Headless-CMS-Lösung für Astro-Projekte, mit der du deine Inhalte mit Astro DB verwalten und bereitstellen kannst. Im Folgenden findest du eine Übersicht über die StudioCMS-Integration und ihre Komponenten.
+
+## Virtuelle Module
+
+Die StudioCMS-Integration bietet mehrere [virtuelle Module](https://vite.dev/guide/api-plugin#virtual-modules-convention), die dir die volle Kontrolle über deine dynamischen Inhalte geben. Diese Module werden in erster Linie intern von StudioCMS verwendet, können aber auch von Entwicklern genutzt werden, um auf StudioCMS-Daten zuzugreifen. Im Folgenden sind die virtuellen Module aufgeführt, die von der StudioCMS-Integration bereitgestellt werden:
+
+### Virtuelle Module zur Authentifizierung
+
+- **`studiocms:auth/lib/encryption`**: Verschlüsselungsprogramme für StudioCMS.
+- **`studiocms:auth/lib/password`**: Dienstprogramme zur Passwortverwaltung für StudioCMS.
+- **`studiocms:auth/lib/rate-limit`**: Dienstprogramme zur Ratenbegrenzung für StudioCMS.
+- **`studiocms:auth/lib/session`**: Dienstprogramme zur Sitzungsverwaltung für StudioCMS.
+- **`studiocms:auth/lib/types`**: Typen für die StudioCMS auth lib für StudioCMS.
+- **`studiocms:auth/lib/user`**: Dienstprogramme zur Benutzerverwaltung für StudioCMS.
+- **`studiocms:auth/utils/authEnvCheck`**: Dienstprogramme zur Überprüfung der Authentifizierungsumgebung für StudioCMS.
+- **`studiocms:auth/utils/getLabelForPermissionLevel`**: Hilfsmittel, um die Bezeichnung für eine Berechtigungsstufe für StudioCMS zu erhalten.
+
+### Virtuelle Kernmodule
+
+- **`studiocms:config`**: Bietet die gelöste Konfiguration für das StudioCMS-Integrationsökosystem.
+- **`studiocms:version`**: Stellt die aktuelle Version des StudioCMS-Integrationsökosystems bereit.
+- **`studiocms:plugins`**: Stellt die Plugin-Systemschnittstellen während der Laufzeit für StudioCMS bereit.
+- **`studiocms:plugin-helpers`**: Stellt die Plugin-Hilfsfunktionen für StudioCMS zur Verfügung.
+- **`studiocms:components`**: Stellt exportierte Komponenten für StudioCMS zur Verfügung.
+- **`studiocms:components/Editors`**: Stellt die Editor-Komponenten für die Seitenbearbeitung zur Verfügung.
+- **`studiocms:components/dashboard-grid-components`**: Interne Komponenten, die vom StudioCMS Dashboard verwendet werden.
+- **`studiocms:components/dashboard-grid-items`**: Interne Komponenten, die vom StudioCMS Dashboard verwendet werden.
+- **`studiocms:component-proxy`**: Stellt den Komponenten-Proxy für benutzerdefinierte Komponenten in StudioCMS zur Verfügung.
+- **`studiocms:lib`**: Stellt die StudioCMS-Bibliothekshelfer für StudioCMS bereit.
+
+### Virtuelle Module des SDK
+
+- **`studiocms:sdk`** Stellt das StudioCMS SDK für StudioCMS bereit
+- **`studiocms:sdk/cache`** Stellt den StudioCMS SDK-Cache für StudioCMS zur Verfügung.
+- **`studiocms:sdk/types`** Stellt die StudioCMS SDK-Typen für StudioCMS zur Verfügung.
+
+### Virtuelle i18n-Module
+
+- **`studiocms:i18n`**: Bietet die StudioCMS i18n für StudioCMS
+
+### Virtuelle Module des Renderers
+
+- **`studiocms:renderer`** Stellt den StudioCMS-Renderer für StudioCMS bereit
+- **`studiocms:renderer/config`** Stellt die StudioCMS Renderer-Konfiguration für StudioCMS bereit.
+- **`studiocms:renderer/current`** Stellt den aktuellen StudioCMS-Renderer für StudioCMS zur Verfügung.
+- **`studiocms:renderer/markdown-remark/css`** Stellt den StudioCMS Renderer markdown-remark css für StudioCMS zur Verfügung.
+
+### Virtuelle Module des ImageHandlers
+
+- **`studiocms:imageHandler/components`**: Stellt die StudioCMS imageHandler Komponenten für StudioCMS zur Verfügung.
+
+## Routen
+
+Die StudioCMS-Integration bietet mehrere Routen, mit denen du deine Inhalte und Konfigurationen verwalten kannst. Diese Routen werden vom StudioCMS Dashboard und der API verwendet, um mit der StudioCMS-Integration zu interagieren. Im Folgenden findest du eine Aufschlüsselung der Routen, die von der StudioCMS-Integration bereitgestellt werden
+
+### Dashboard-Routen
+
+Die Routen, auf die Benutzer zugreifen können, um ihr StudioCMS-Projekt zu verwalten.
+
+#### Hauptrouten
+
+- **`/dashboard/`**: Das StudioCMS-Dashboard, in dem du dein StudioCMS-Projekt verwalten kannst.
+- **`/dashboard/profile/`**: Die StudioCMS Dashboard Profilseite, auf der du dein Profil verwalten kannst.
+- **`/dashboard/content-management/`**: Die StudioCMS Dashboard Inhaltsverwaltungsseite, auf der du deine Inhalte verwalten kannst.
+- **`/dashboard/configuration/`**: Die StudioCMS Dashboard Konfigurationsseite, auf der du deine Konfiguration verwalten kannst.
+- **`/dashboard/user-management/`**: Die StudioCMS Dashboard Benutzerverwaltungsseite, auf der du deine Benutzer verwalten kannst.
+- **`/dashboard/plugins/`**: Die StudioCMS Dashboard Plugins Seite, auf der du deine Plugins verwalten kannst.
+
+#### Auth-Routen
+
+- **`/dashboard/login/`**: Die StudioCMS Dashboard Anmeldeseite.
+- **`/dashboard/signup/`**: Die StudioCMS Dashboard Anmeldeseite.
+- **`/dashboard/logout/`**: Die StudioCMS Dashboard Abmeldeseite.
+
+### API-Routen
+
+Die Routen, die das StudioCMS Dashboard für die Interaktion mit der StudioCMS-Integration verwendet.
+
+#### Hauptrouten
+
+- **`/studiocms_api/dashboard/api-tokens`**: Der Endpunkt für die StudioCMS-API-Tokens.
+- **`/studiocms_api/dashboard/search-list`**: Der Endpunkt für die StudioCMS-API-Suchliste.
+- **`/studiocms_api/dashboard/live-render`**: Der StudioCMS-API-Live-Rendering-Teil-Endpunkt.
+- **`/studiocms_api/dashboard/user-list-items`**: Der StudioCMS API Endpunkt für die Benutzerliste.
+- **`/studiocms_api/dashboard/editor`**: Der StudioCMS-API-Editor-Endpunkt.
+- **`/studiocms_api/dashboard/config`**: Der Endpunkt für die StudioCMS-API-Konfiguration.
+- **`/studiocms_api/dashboard/users`**: Der Endpunkt für die StudioCMS-API-Benutzer.
+- **`/studiocms_api/dashboard/profile`**: Der StudioCMS-API-Profil-Endpunkt.
+- **`/studiocms_api/dashboard/create-reset-link`**: Der StudioCMS-API-Endpunkt zum Erstellen eines Reset-Links.
+- **`/studiocms_api/dashboard/reset-password`**: Der StudioCMS-API-Endpunkt zum Zurücksetzen des Passworts.
+- **`/studiocms_api/dashboard/content/page`**: Der Endpunkt der StudioCMS-API-Inhaltsseite.
+- **`/studiocms_api/dashboard/content/folder`**: Der Endpunkt für den StudioCMS-API-Inhaltsordner.
+- **`/studiocms_api/dashboard/plugins`**: Der Endpunkt für die StudioCMS-API-Plugins.
+- **`/studiocms_api/dashboard/create-user`**: Der StudioCMS-API-Endpunkt zum Erstellen von Benutzern.
+- **`/studiocms_api/dashboard/update-user-invite`**: Der StudioCMS-API-Endpunkt zum Aktualisieren von Benutzereinladungen.
+
+#### Auth-Routen
+
+- **`/studiocms_api/auth/login`**: Der StudioCMS-API-Anmeldeendpunkt.
+- **`/studiocms_api/auth/logout`**: Der StudioCMS-API-Abmeldeendpunkt.
+- **`/studiocms_api/auth/register`**: Der StudioCMS-API-Registrierungsendpunkt.
+- **`/studiocms_api/auth/github`**: Der StudioCMS API GitHub Endpunkt.
+- **`/studiocms_api/auth/github/callback`**: Der StudioCMS API GitHub Callback Endpunkt.
+- **`/studiocms_api/auth/discord`**: Der StudioCMS API Discord Endpunkt.
+- **`/studiocms_api/auth/discord/callback`**: Der StudioCMS API Discord Callback Endpunkt.
+- **`/studiocms_api/auth/google`**: Der StudioCMS API Google Endpunkt.
+- **`/studiocms_api/auth/google/callback`**: Der StudioCMS API Google Callback Endpunkt.
+- **`/studiocms_api/auth/auth0`**: Der StudioCMS API Auth0 Endpunkt.
+- **`/studiocms_api/auth/auth0/callback`**: Der StudioCMS API Auth0 Callback Endpunkt.
+
+#### SDK-Routen
+
+- **`/studiocms_api/sdk/list-pages`**: Der StudioCMS API SDK Seiten Endpunkt.
+- **`/studiocms_api/sdk/fallback-list-pages.json`**: Der Endpunkt für die StudioCMS API SDK Fallback-Listenseiten.
+- **`/studiocms_api/sdk/update-latest-version-cache`**: Der StudioCMS API SDK update latest version cache Endpunkt.
+
+#### Renderer-Routen
+
+- **`/studiocms_api/renderer/render`**: Der StudioCMS API Render-Endpunkt.
\ No newline at end of file
diff --git a/src/content/docs/de/how-it-works/restapi.mdx b/src/content/docs/de/how-it-works/restapi.mdx
new file mode 100644
index 00000000..74e5d18f
--- /dev/null
+++ b/src/content/docs/de/how-it-works/restapi.mdx
@@ -0,0 +1,42 @@
+---
+i18nReady: true
+title: "Die REST-API"
+description: "Erfahre mehr über die StudioCMS REST API und wie du sie nutzen kannst."
+sidebar:
+ order: 4
+---
+
+# Einführung
+
+Die StudioCMS REST API ist ein leistungsstarkes Werkzeug, mit dem du programmatisch mit deinen StudioCMS-Inhalten interagieren kannst. Sie bietet eine einfache und flexible Möglichkeit, deine Inhalte mit Astro DB zu verwalten und bereitzustellen.
+
+Die StudioCMS REST API wird von Astro Endpoints unterstützt und bietet eine RESTful-Schnittstelle für die Interaktion mit deinen StudioCMS-Inhalten. Im Folgenden findest du eine Übersicht über die StudioCMS REST API und ihre Komponenten.
+
+## API-Tokens
+
+Um auf die geschützten Endpunkte der StudioCMS REST API zugreifen zu können, musst du ein API-Token im `Authorization`-Header deiner Anfragen angeben. Du kannst ein API-Token generieren, indem du dich im StudioCMS Dashboard anmeldest und zum Abschnitt „API-Token“ im Benutzerprofil navigierst.
+
+## Endpunkte
+
+Die StudioCMS REST-API bietet mehrere Endpunkte, über die du mit deinen StudioCMS-Inhalten interagieren kannst. Diese Endpunkte werden hauptsächlich intern von StudioCMS verwendet, können aber auch von Entwicklern genutzt werden, um mit StudioCMS-Daten zu interagieren. Im Folgenden sind die Endpunkte aufgeführt, die von der StudioCMS REST API bereitgestellt werden:
+
+### Öffentliche Endpunkte
+
+Diese Endpunkte sind für die Öffentlichkeit zugänglich und erfordern keine Authentifizierung. Sie bieten einen reinen Lesezugriff auf den StudioCMS-Inhaltsbaum. Daher unterstützen diese Endpunkte nur `GET`-Anfragen.
+
+- **`/studiocms_api/rest/v1/public/folders/`**: Liefert eine Liste aller öffentlichen Ordner im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/public/folders/[id]`**: Liefert Details zu einem bestimmten öffentlichen Ordner im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/public/pages/`**: Liefert eine Liste aller öffentlichen Seiten im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/public/pages/[id]`**: Liefert Details zu einer bestimmten öffentlichen Seite im StudioCMS-Inhaltsbaum.
+
+### Geschützte Endpunkte
+
+- **`/studiocms_api/rest/v1/folders/`**: Liefert eine Liste aller Ordner im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/folders/[id]`**: Liefert Details zu einem bestimmten Ordner im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/pages/`**: Liefert eine Liste aller Seiten im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/pages/[id]`**: Liefert Details zu einer bestimmten Seite im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/pages/[id]/history/`**: Liefert eine Liste aller Einträge der Seitenhistorie im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/pages/[id]/history/[id]`**: Liefert Details für einen bestimmten Seitenverlaufseintrag im StudioCMS-Inhaltsbaum.
+- **`/studiocms_api/rest/v1/settings/`**: Stellt die StudioCMS-Einstellungen für das aktuelle Projekt bereit.
+- **`/studiocms_api/rest/v1/users/`**: Liefert eine Liste aller Benutzer im StudioCMS-Projekt.
+- **`/studiocms_api/rest/v1/users/[id]`**: Liefert Details zu einem bestimmten Benutzer im StudioCMS-Projekt.
diff --git a/src/content/docs/de/how-it-works/sdk.mdx b/src/content/docs/de/how-it-works/sdk.mdx
new file mode 100644
index 00000000..5699b5fa
--- /dev/null
+++ b/src/content/docs/de/how-it-works/sdk.mdx
@@ -0,0 +1,293 @@
+---
+i18nReady: true
+title: "Das SDK"
+description: "Learn about the StudioCMS SDK and how to use it."
+sidebar:
+ order: 3
+---
+
+import ReadMore from '~/components/ReadMore.astro';
+
+Das StudioCMS SDK ist ein leistungsstarkes Werkzeug, mit dem du programmatisch mit StudioCMS interagieren kannst. Es bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du deine Inhalte mit Astro DB verwalten und bereitstellen kannst. Außerdem bildet es das Rückgrat für das StudioCMS-Dashboard.
+
+## Verwendung
+
+Das StudioCMS SDK ist als virtuelles Modul in deinem Astro-Projekt verfügbar. Du kannst es mit der folgenden Syntax importieren:
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+// Or
+import SDKCached from 'studiocms:sdk/cache';
+```
+
+Das Objekt `studioCMSSDK` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du mit StudioCMS interagieren kannst. Du kannst diese Funktionen nutzen, um Inhalte in deinem Astro-Projekt zu erstellen, zu lesen, zu aktualisieren und zu löschen.
+
+Das Objekt `studioCMSSDKCached` bietet eine Reihe von Funktionen und Dienstprogrammen, die es dir ermöglichen, mit dem StudioCMS SDK zu interagieren und es mit einer Caching-Schicht zu versehen. Du kannst diese Funktionen nutzen, um Inhalte in deinem Astro-Projekt zwischenzuspeichern.
+
+## StudioCMS SDK (Standard)
+
+### `SDK.AUTH`
+
+Das Objekt `SDK.AUTH` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du die Authentifizierung in deinem Astro-Projekt verwalten kannst. Du kannst diese Funktionen nutzen, um Benutzer zu authentifizieren, Sitzungen zu verwalten und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ oAuth,
+ permission,
+ session,
+ user,
+} = SDK.AUTH;
+```
+
+### `SDK.INIT`
+
+Das Objekt `SDK.INIT` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du das StudioCMS SDK in deinem Astro-Projekt initialisieren kannst. Du kannst diese Funktionen nutzen, um das SDK einzurichten, zu konfigurieren und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ siteConfig,
+ ghostUser,
+} = SDK.INIT;
+```
+
+### `SDK.GET`
+
+Das Objekt `SDK.GET` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du Inhalte aus Astro DB abrufen kannst. Du kannst diese Funktionen nutzen, um Inhalte nach ID, nach Typ und mehr abzurufen.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ database,
+ databaseEntry,
+ databaseTable,
+ permissionsLists,
+ packagePages,
+} = SDK.GET;
+```
+
+### `SDK.POST`
+
+Das Objekt `SDK.POST` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du Inhalte in Astro DB erstellen kannst. Du kannst diese Funktionen nutzen, um Inhalte nach Typ zu erstellen, Inhalte nach ID zu erstellen und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ databaseEntry,
+ databaseEntries,
+} = SDK.POST;
+```
+
+### `SDK.UPDATE`
+
+Das Objekt `SDK.UPDATE` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du Inhalte in Astro DB aktualisieren kannst. Du kannst diese Funktionen nutzen, um Inhalte nach ID zu aktualisieren, Inhalte nach Typ zu aktualisieren und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ page,
+ pageContent,
+ tags,
+ categories,
+ permissions,
+ siteConfig,
+ folder,
+} = SDK.UPDATE;
+```
+
+### `SDK.DELETE`
+
+Das Objekt `SDK.DELETE` bietet eine Reihe von Funktionen und Hilfsmitteln, mit denen du Inhalte aus Astro DB löschen kannst. Du kannst diese Funktionen nutzen, um Inhalte nach ID, nach Typ und mehr zu löschen.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ page,
+ pageContent,
+ pageContentLang,
+ tags,
+ categories,
+ permissions,
+ diffTracking,
+ folder,
+ user,
+} = SDK.DELETE;
+```
+
+### `SDK.db`
+
+Das Objekt `SDK.db` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du direkt mit der Astro-DB interagieren kannst. Du kannst diese Funktionen nutzen, um die Datenbank abzufragen, benutzerdefinierte Abfragen durchzuführen und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const { db } = SDK;
+```
+
+Weitere Informationen über die Verwendung von `db` findest du im [Astro DB Guide](https://docs.astro.build/en/guides/astro-db/)
+
+### `SDK.REST_API`
+
+Das Objekt `SDK.REST_API` bietet eine Reihe von Funktionen und Dienstprogrammen, die die REST-API verwendet, um mit dem StudioCMS und der Astro DB zu interagieren.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ tokens: {
+ get: getToken,
+ new: newToken,
+ delete: deleteToken,
+ verify: verifyToken,
+ },
+} = SDK.REST_API;
+```
+
+### `SDK.diffTracking`
+
+Das Objekt `SDK.diffTracking` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du Änderungen in Astro DB verfolgen kannst. Du kannst diese Funktionen nutzen, um Änderungen an Inhalten, an Benutzern und mehr zu verfolgen.
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ insert,
+ clear,
+ get,
+ revertToDiff
+} = SDK.diffTracking;
+```
+
+### Nützliche Funktionen
+
+Das StudioCMS SDK bietet auch eine Reihe von Hilfsfunktionen, mit denen du mit dem SDK interagieren kannst. Zu diesen Funktionen gehören:
+
+```ts twoslash
+///
+// ---cut---
+import SDK from 'studiocms:sdk';
+
+const {
+ addPageToFolderTree,
+ findNodeById,
+ findNodeByPath,
+ findNodesAlongPath,
+ getFullPath,
+ parseIdNumberArray,
+ parseIdStringArray,
+ generateRandomIDNumber,
+ generateToken,
+ testToken,
+ combineRanks,
+ verifyRank,
+ buildFolderTree,
+ getAvailableFolders,
+ clearUserReferences,
+ collectCategories,
+ collectTags,
+ collectPageData,
+ collectUserData,
+ generateRandomPassword,
+} = SDK;
+```
+
+## StudioCMS SDK (Cached)
+
+Das StudioCMS SDK bietet auch eine gecachte Version des SDK mit einer begrenzten Untermenge der SDK-Funktionen, die eine Caching-Schicht über dem Standard-SDK enthält. Du kannst das gecachte SDK mit der folgenden Syntax importieren:
+
+```ts twoslash
+///
+// ---cut---
+import SDKCached from 'studiocms:sdk/cache';
+```
+
+### `SDKCached.GET`
+
+Das Objekt `SDKCached.GET` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du Inhalte aus der Astro-DB abrufen kannst, die mit einer Zwischenspeicherschicht versehen sind. Du kannst diese Funktionen nutzen, um Inhalte nach ID, nach Typ und mehr abzurufen.
+
+```ts twoslash
+///
+// ---cut---
+import SDKCached from 'studiocms:sdk/cache';
+
+const {
+ page,
+ pages,
+ siteConfig,
+ latestVersion,
+ folderTree,
+ pageFolderTree,
+ folderList,
+ folder,
+} = SDKCached.GET;
+```
+
+### `SDKCached.CLEAR`
+
+Das Objekt `SDKCached.CLEAR` bietet eine Reihe von Funktionen und Hilfsmitteln, mit denen du den Cache im SDK-Cache löschen kannst. Du kannst diese Funktionen verwenden, um den Cache für einen bestimmten Inhaltstyp zu löschen, den Cache für eine bestimmte Inhalts-ID zu löschen und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDKCached from 'studiocms:sdk/cache';
+
+const {
+ page,
+ pages,
+ latestVersion,
+ folderTree,
+ folderList,
+} = SDKCached.CLEAR;
+```
+
+### `SDKCached.UPDATE`
+
+Das Objekt `SDKCached.UPDATE` bietet eine Reihe von Funktionen und Dienstprogrammen, mit denen du Inhalte in Astro DB mit einer Zwischenspeicherschicht aktualisieren kannst. Du kannst diese Funktionen nutzen, um Inhalte nach ID zu aktualisieren, Inhalte nach Typ zu aktualisieren und vieles mehr.
+
+```ts twoslash
+///
+// ---cut---
+import SDKCached from 'studiocms:sdk/cache';
+
+const {
+ page,
+ siteConfig,
+ latestVersion,
+ folderTree,
+ folderList,
+ folder,
+} = SDKCached.UPDATE;
+```
+
+### `SDKCached.db`
+
+Dies ist ein Passthrough zum Standard SDK `db` Objekt.
+
+Siehe [`SDK.db`](#sdkdb) für weitere Informationen
\ No newline at end of file
diff --git a/src/content/docs/de/package-catalog/community-plugins/web-vitals.mdx b/src/content/docs/de/package-catalog/community-plugins/web-vitals.mdx
new file mode 100644
index 00000000..ca6b6c76
--- /dev/null
+++ b/src/content/docs/de/package-catalog/community-plugins/web-vitals.mdx
@@ -0,0 +1,78 @@
+---
+i18nReady: true
+title: "@astrojs/web-vitals"
+type: integration
+catalogEntry: astrojs-web-vitals
+description: "Web Vitals Integration mit dem StudioCMS Dashboard"
+sidebar:
+ badge:
+ text: 'Plugin'
+ variant: 'tip'
+---
+
+import { PackageManagers } from 'starlight-package-managers'
+import Gallery from '~/components/Gallery.astro';
+import { webVitalsImages } from "~/assets/index.ts";
+import { Steps, Tabs, TabItem } from '@astrojs/starlight/components';
+
+# Einführung
+
+Diese Astro-Integration ermöglicht die Verfolgung der realen Website-Leistung und die Speicherung der Daten in der Astro-DB. Diese Daten werden im StudioCMS-Dashboard verwendet, um die Leistungsmetriken deiner Website aus der realen Welt im Laufe der Zeit anzuzeigen.
+
+## Installation
+
+
+{/* */}
+
+1. Installiere das Paket und füge es mit dem folgenden Befehl zu deiner Astro-Konfiguration hinzu:
+
+
+
+2. Übertrage die neue Konfiguration auf deine Ferndatenbank:
+
+
+
+{/* */}
+
+
+{/* */}
+
+1. Installiere das Paket mit dem folgenden Befehl:
+
+
+
+2. Füge `@astrojs/web-vitals` zu deiner Astro-Konfigurationsdatei hinzu:
+
+ ```ts twoslash title="astro.config.mjs" {12} ins={4, 13}
+ import node from '@astrojs/node';
+ import studioCMS from 'studiocms';
+ import db from '@astrojs/db';
+ import webVitals from '@astrojs/web-vitals';
+ import { defineConfig } from 'astro/config';
+
+ export default defineConfig({
+ site: 'https://demo.studiocms.dev/',
+ output: 'server',
+ adapter: node({ mode: "standalone" }),
+ integrations: [
+ db(), // ERFORDERLICH
+ webVitals(),
+ studioCMS(),
+ ],
+ });
+ ```
+
+
+
+3. Übertrage die neue Konfiguration auf deine remote Datenbank:
+
+
+
+{/* */}
+
+
+
+
+{/* ## Gallery Demo
+
+ */}
diff --git a/src/content/docs/de/package-catalog/index.mdx b/src/content/docs/de/package-catalog/index.mdx
new file mode 100644
index 00000000..64f626a3
--- /dev/null
+++ b/src/content/docs/de/package-catalog/index.mdx
@@ -0,0 +1,26 @@
+---
+i18nReady: true
+title: Pakete
+description: Der Paketkatalog ist eine Sammlung von Paketen von StudioCMS oder seiner Community.
+---
+
+import PackageCatalog from '~/components/PackageCatalog.astro'
+import { Badge } from '@astrojs/starlight/components';
+
+Der Paketkatalog ist eine Sammlung von Paketen von StudioCMS oder seinen Community-Mitgliedern, die nicht standardmäßig in StudioCMS enthalten sind. Alle hier aufgeführten Pakete wurden vom StudioCMS-Team oder seinen Mitwirkenden überprüft und getestet.
+
+Jedes Paket, das als gekennzeichnet ist, ist ein Paket, das die Funktionalität von StudioCMS oder seinem Dashboard erweitert.
+
+Jedes Paket, das als gekennzeichnet ist, kann installiert und in Projekten verwendet werden, die nicht auf StudioCMS angewiesen sind. Sie können eigenständig arbeiten.
+
+## Paket-Kataloge
+
+### StudioCMS-Pakete
+---
+
+
+
+### Community-Pakete
+---
+
+
\ No newline at end of file
diff --git a/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-blog.mdx b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-blog.mdx
new file mode 100644
index 00000000..4b1cdba1
--- /dev/null
+++ b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-blog.mdx
@@ -0,0 +1,48 @@
+---
+i18nReady: true
+title: "@studiocms/blog"
+type: integration
+catalogEntry: studiocms-blog
+description: "StudioCMS Blog-Integration"
+sidebar:
+ badge:
+ text: 'Plugin'
+ variant: 'tip'
+---
+
+import { PackageManagers } from 'starlight-package-managers'
+import { Steps, Tabs, TabItem } from '@astrojs/starlight/components';
+
+# Einführung
+
+Dieses Plugin aktiviert die StudioCMS Blog-Funktionen sowie ein Frontend in deinem Astro-Projekt. Es ermöglicht dir, Blogbeiträge über das StudioCMS-Dashboard zu erstellen, zu bearbeiten und zu löschen.
+
+## Installation
+
+1. Installiere das Paket mit dem folgenden Befehl:
+
+
+
+2. Füge `@studiocms/blog` zu deiner Astro-Konfigurationsdatei hinzu:
+
+ ```ts twoslash title="studiocms.config.mjs" ins={2, 6}
+ import { defineStudioCMSConfig } from 'studiocms/config';
+ import blog from '@studiocms/blog';
+
+ export default defineStudioCMSConfig({
+ plugins: [
+ blog(),
+ ],
+ });
+ ```
+
+## Verwendung
+
+### Was macht dieses Plugin?
+
+Diese Integration fügt deinem StudioCMS-gesteuerten Frontend die folgenden neuen Routen hinzu:
+
+- `/[...slug]` - Die Hauptblogseite, die alle StudioCMS-Seiten auflistet.
+- `/blog` - Die Hauptblogseite, die alle Blogbeiträge auflistet.
+- `/blog/[slug]` - Die Seite mit den einzelnen Blogbeiträgen.
+- `/rss.xml` - Der RSS-Feed für deine Blogbeiträge.
diff --git a/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-devapps.mdx b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-devapps.mdx
new file mode 100644
index 00000000..7e51fb5e
--- /dev/null
+++ b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-devapps.mdx
@@ -0,0 +1,132 @@
+---
+i18nReady: true
+title: "@studiocms/devapps"
+type: integration
+catalogEntry: studiocms-devapps
+description: "Eine Sammlung nützlicher Tools, die im Entwicklungsmodus in Astro verfügbar sind"
+sidebar:
+ badge:
+ text: 'Publicly Usable'
+ variant: 'caution'
+---
+
+import { PackageManagers } from 'starlight-package-managers'
+import { Steps, Tabs, TabItem } from '@astrojs/starlight/components';
+
+# Einführung
+
+Eine Sammlung nützlicher Werkzeuge, die im Entwicklungsmodus von Astro verfügbar sind.
+
+## Installation
+
+
+
+{/* */}
+1. Installiere das Paket und füge es mit dem folgenden Befehl zu deiner Astro-Konfiguration hinzu:
+
+
+
+2. Aktualisiere deine Konfigurationsdatei wie unter [der Beispielkonfiguration](#beispielkonfiguration) unten gezeigt.
+{/* */}
+
+
+{/* */}
+1. Installiere das Paket mit dem folgenden Befehl:
+
+
+
+2. Füge `@studiocms/devapps` zu deiner Astro-Konfigurationsdatei hinzu:
+
+ ```ts twoslash title="astro.config.mjs" ins={3, 9}
+ import { defineConfig } from 'astro/config';
+ import db from '@astrojs/db';
+ import devApps from '@studiocms/devapps';
+
+ export default defineConfig({
+ site: "https://example.com",
+ integrations: [
+ db(),
+ devApps(),
+ ],
+ });
+ ```
+{/* */}
+
+
+
+## Verwendung
+
+Alle Tools sind nur während der Entwicklungsphase (`astro dev`) verfügbar und nicht während der Produktionsphase!
+
+### Beispielkonfiguration
+
+```ts twoslash title="astro.config.mjs" {2, 8} ins={3, 9}
+import { defineConfig } from 'astro/config';
+import db from '@astrojs/db';
+import devApps from '@studiocms/devapps';
+
+export default defineConfig({
+ site: "https://example.com",
+ integrations: [
+ db(), // ERFORDERLICH
+ devApps(/* Siehe Konfigurationsoptionen unten */),
+ ],
+});
+```
+
+### Konfigurationsoptionen
+
+Vollständige Liste der Optionen, die für die `devApps`-Integration verfügbar sind, mit Angabe der Standardwerte. **Alle Optionen sind optional**.
+
+```ts twoslash
+import devApps from '@studiocms/devapps';
+devApps({
+// ---cut---
+endpoint: '_studiocms-devapps',
+verbose: false,
+appsConfig: {
+ libSQLViewer: true,
+ wpImporter: true,
+},
+// ---cut-after---
+})
+```
+
+## Werkzeuge
+
+### libSQL-Betrachter
+
+Entwicklungswerkzeug, um die SQL-Tabellen in der libSQL-Datenbank im Browser anzuzeigen. Das Tool benötigt die Anmeldeinformationen für die libSQL-Remote-Datenbankverbindung `@astrojs/db`.
+
+#### Voraussetzungen
+
+Die folgenden Umgebungsvariablen werden gesetzt (auch für `@astrojs/db` verwendet):
+- **`ASTRO_DB_REMOTE_URL`**
+- **`ASTRO_DB_APP_TOKEN`**
+
+#### Vorschau Verwendung
+
+- Symbolleisten-App (geschlossen)
+
+
+
+- Symbolleiste (Erweitert)
+
+
+
+### Wordpress-Importer
+
+Entwicklungstool zum Importieren von WordPress-Beiträgen und -Seiten in die StudioCMS-Datenbank.
+
+#### Voraussetzungen
+
+- StudioCMS-Integration
+- WordPress installieren
+- `@studiocms/blog` (Optional: für den Import von Posts unter einem Blog)
+
+#### Vorschau Verwendung
+
+- Symbolleisten-App
+
+
+
diff --git a/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-markdoc.mdx b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-markdoc.mdx
new file mode 100644
index 00000000..1f64423a
--- /dev/null
+++ b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-markdoc.mdx
@@ -0,0 +1,37 @@
+---
+i18nReady: true
+title: "@studiocms/markdoc"
+type: integration
+catalogEntry: studiocms-markdoc
+description: "StudioCMS MarkDoc-Integration"
+sidebar:
+ badge:
+ text: 'Plugin'
+ variant: 'tip'
+---
+
+import { PackageManagers } from 'starlight-package-managers'
+import { Steps, Tabs, TabItem } from '@astrojs/starlight/components';
+
+# Einführung
+
+Dieses Plugin ermöglicht die MarkDoc-Unterstützung in StudioCMS.
+
+## Installation
+
+1. Installiere das Paket mit dem folgenden Befehl:
+
+
+
+2. Füge `@studiocms/markdoc` zu deiner Astro-Konfigurationsdatei hinzu:
+
+ ```ts twoslash title="studiocms.config.mjs" ins={2, 6}
+ import { defineStudioCMSConfig } from 'studiocms/config';
+ import markdoc from '@studiocms/markdoc';
+
+ export default defineStudioCMSConfig({
+ plugins: [
+ markdoc(),
+ ],
+ });
+ ```
\ No newline at end of file
diff --git a/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-mdx.mdx b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-mdx.mdx
new file mode 100644
index 00000000..529c1f24
--- /dev/null
+++ b/src/content/docs/de/package-catalog/studiocms-plugins/studiocms-mdx.mdx
@@ -0,0 +1,37 @@
+---
+i18nReady: true
+title: "@studiocms/mdx"
+type: integration
+catalogEntry: studiocms-mdx
+description: "StudioCMS MDX-Integration"
+sidebar:
+ badge:
+ text: 'Plugin'
+ variant: 'tip'
+---
+
+import { PackageManagers } from 'starlight-package-managers'
+import { Steps, Tabs, TabItem } from '@astrojs/starlight/components';
+
+# Einführung
+
+Dieses Plugin ermöglicht die MDX-Unterstützung in StudioCMS.
+
+## Installation
+
+1. Installiere das Paket mit dem folgenden Befehl:
+
+
+
+2. Füge `@studiocms/mdx` zu deiner Astro-Konfigurationsdatei hinzu:
+
+ ```ts twoslash title="studiocms.config.mjs" ins={2, 6}
+ import { defineStudioCMSConfig } from 'studiocms/config';
+ import mdx from '@studiocms/mdx';
+
+ export default defineStudioCMSConfig({
+ plugins: [
+ mdx(),
+ ],
+ });
+ ```
\ No newline at end of file
diff --git a/src/content/docs/de/plugins/extended.mdx b/src/content/docs/de/plugins/extended.mdx
new file mode 100644
index 00000000..05c2acc9
--- /dev/null
+++ b/src/content/docs/de/plugins/extended.mdx
@@ -0,0 +1,317 @@
+---
+i18nReady: true
+title: Plugins nützlich machen
+description: Erfahre mehr über die StudioCMS Plugins und wie sie funktionieren.
+sidebar:
+ order: 2
+---
+
+import ReadMore from '~/components/ReadMore.astro'
+import { FileTree } from '@astrojs/starlight/components'
+
+# Einführung
+
+Die Erstellung eines StudioCMS-Plugins ist eine leistungsstarke Möglichkeit, die Funktionalität von StudioCMS zu erweitern. Sie bieten eine einfache und flexible Möglichkeit, neue Funktionen zu deinem StudioCMS-Projekt hinzuzufügen. Das folgende Beispiel zeigt dir, wie du ein StudioCMS-Plugin erstellst und wie es funktioniert.
+
+## Erste Schritte
+
+Um loszulegen, musst du ein neues StudioCMS-Plugin erstellen. Im Folgenden findest du ein grundlegendes Beispiel für die Dateistruktur eines StudioCMS-Plugins:
+
+
+
+
+- package.json
+- src
+ - index.ts
+ - routes
+ - [...slug].astro
+ - dashboard-grid-items
+ - MyPluginGridItem.astro
+
+
+
+## Erstellen des Plugins
+
+In der Hauptdatei `src/index.ts` definierst du das StudioCMS Plugin. Das folgende Beispiel zeigt, wie du ein StudioCMS-Plugin definierst, das eine Astro-Integration enthält, um ein einfaches Blog-Beispiel zu erstellen:
+
+```ts twoslash title="index.ts"
+import { definePlugin } from 'studiocms/plugins';
+import { AstroIntegration } from 'astro';
+import { addVirtualImports, createResolver } from 'astro-integration-kit';
+
+// Definiere die Optionen für das Plugin und die Integration
+interface Options {
+ route: string;
+}
+
+export function studioCMSPageInjector(options: Options) {
+
+ // Löse den Pfad zur aktuellen Datei auf
+ const { resolve } = createResolver(import.meta.url);
+
+ // Definiere die Astro-Integration
+ function myIntegration(options: Options): AstroIntegration {
+ const route = `/${options?.route || 'my-plugin'}`;
+
+ return {
+ name: 'my-astro-integration',
+ hooks: {
+ "astro:config:setup": (params) => {
+ const { injectRoute } = params;
+
+ // Injiziere die Route für das Plugin
+ injectRoute({
+ entrypoint: resolve('./routes/[...slug].astro'),
+ pattern: `/${route}/[...slug]`,
+ prerender: false,
+ })
+
+ addVirtualImports(params, {
+ name: 'my-astro-integration',
+ imports: {
+ 'myplugin:config': `
+ export const options = ${JSON.stringify({ route })};
+ export default options;
+ `,
+ }
+ })
+ }
+ }
+ }
+ }
+
+ // Definiere das StudioCMS Plugin
+ return definePlugin({
+ identifier: 'my-plugin',
+ name: 'My Plugin',
+ studiocmsMinimumVersion: '0.1.0-beta.8',
+ integration: myIntegration(options), // Optional, aber empfohlen
+ // Definiere die Frontend-Navigationslinks für das Plugin (optional)
+ // Dies ist nützlich, wenn du die eingebauten StudioCMS-Navigationshilfen in deinem Layout verwendest,
+ // wie z.B. bei der Verwendung des Plugins `@studiocms/blog`.
+ frontendNavigationLinks: [{ label: 'Title here', href: options?.route || 'my-plugin' }],
+ // Wenn du pageTypes erstellst, kannst du auch eine `pageContentComponent` definieren, wenn dein Plugin einen eigenen Inhaltseditor benötigt.
+ // pageTypes: [{ identifier: 'my-plugin', label: 'Blog Post (My Plugin)', pageContentComponent: resolve('./components/MyContentEditor.astro') }],
+ // In diesem Beispiel ist es in Ordnung, den Standard-Editor (Markdown) zu verwenden.
+ pageTypes: [{ identifier: 'my-plugin', label: 'Blog Post (My Plugin)' }],
+ // Definiere die Gitterelemente für das Dashboard
+ // Dies sind die Elemente, die auf dem StudioCMS Dashboard angezeigt werden
+ // Du kannst so viele Elemente definieren, wie du willst
+ // In diesem Beispiel definieren wir ein einzelnes Element, das eine Spannweite von 2 hat und die Berechtigung „Editor“ benötigt. Außerdem injizieren wir eine Astro-Komponente, die das einfache benutzerdefinierte HTML-Element ersetzt.
+ dashboardGridItems: [
+ {
+ name: 'example',
+ span: 2,
+ variant: 'default',
+ requiresPermission: 'editor',
+ header: { title: 'Example', icon: 'bolt' },
+ body: {
+ // Verwende immer einfaches HTML ohne `-` oder Sonderzeichen in den Tags. Sie werden durch die Astro-Komponente ersetzt und dieses HTML wird nie gerendert.
+ html: '',
+ components: {
+ // Injiziere die Astro-Komponente, um das einfache benutzerdefinierte HTML-Element zu ersetzen
+ examplegriditem: resolve('./dashboard-grid-items/MyPluginGridItem.astro')
+ }
+ }
+ }
+ ],
+ });
+}
+```
+
+Das obige Beispiel definiert ein StudioCMS-Plugin, das eine Astro-Integration enthält, um ein einfaches Blog-Beispiel zu erstellen. Das Plugin enthält eine Route, die in das StudioCMS-Projekt injiziert wird, und ein Grid-Element, das auf dem StudioCMS-Dashboard angezeigt wird.
+
+Weitere Informationen darüber, wie du eine Astro-Integration erstellst, findest du im [Astro Integration Kit](https://astro-integration-kit.netlify.app/) und in der [Astro Integrations Dokumentation](https://docs.astro.build/de/reference/integrations-reference/).
+
+## Beispiel-Route
+
+In der Datei `src/routes/[...slug].astro` definierst du die Route für das Plugin. Das folgende Beispiel zeigt, wie du eine Route für das Plugin definierst. Der erste Teil ist das Frontmatter (zwischen den `---`-Zeichen) und der zweite Teil ist die HTML-Vorlage, die unter dem zweiten `---` eingefügt wird.
+
+```ts twoslash title="Frontmatter"
+// @noErrors
+// @filename: plugin.d.ts
+declare module 'myplugin:config' {
+ export const options: { route: string };
+ export default options;
+}
+// ---cut---
+// @filename: Frontmatter.ts
+///
+///
+import type { AstroGlobal } from 'astro';
+const Astro: AstroGlobal = {};
+// ---cut---
+import { StudioCMSRenderer } from 'studiocms:renderer';
+import sdk from 'studiocms:sdk';
+import config from 'myplugin:config';
+
+const makeRoute = (slug: string) => {
+ return `/${config.route}/${slug}`;
+}
+
+// 'my-plugin' wird hier als Bezeichner für
+// den pageType aus der Plugin-Definition verwendet
+const pages = await sdk.GET.packagePages('my-plugin');
+
+const { slug } = Astro.params;
+
+const page = pages.find((page) => page.slug === slug || '');
+```
+
+```astro title="Template"
+{
+ slug && page ? (
+
+ )
+}
+```
+
+Das obige Beispiel definiert eine [dynamische Route](https://docs.astro.build/de/guides/routing//#dynamische-routen) für das Plugin, die eine Liste von Blogposts anzeigt, wenn kein Slug angegeben wird, und die den Inhalt eines Blogposts anzeigt, wenn ein Slug angegeben wird.
+
+## Beispiel Gitterelement
+
+In der Datei `src/dashboard-grid-items/MyPluginGridItem.astro` definierst du das Grid Item für das Plugin. Das folgende Beispiel zeigt, wie du ein Grid Item für das Plugin definierst:
+
+```astro title="MyPluginGridItem.astro"
+---
+import { StudioCMSRoutes } from 'studiocms:lib';
+import sdk from 'studiocms:sdk';
+
+// 'my-plugin' wird hier als Bezeichner für
+// den pageType aus der Plugin-Definition verwendet
+const pages = await sdk.GET.packagePages('my-plugin');
+
+// Erhalte die 5 zuletzt aktualisierten Seiten der letzten 30 Tage
+const recentlyUpdatedPages = pages
+ .filter((page) => {
+ const now = new Date();
+ const thirtyDaysAgo = new Date(now.setDate(now.getDate() - 30));
+ return new Date(page.updatedAt) > thirtyDaysAgo;
+ })
+ .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+ .slice(0, 5);
+---
+
+
+```
+
+Das obige Beispiel definiert ein Grid-Element für das Plugin, das die 5 zuletzt aktualisierten Seiten der letzten 30 Tage anzeigt. Das Grid-Element enthält eine Liste mit Links zu den Bearbeitungsseiten der einzelnen Seiten im Content Management.
+
+## Integration mit den FrontendNavigationLinks Helfern
+
+Wenn du die eingebauten StudioCMS-Navigationshilfen in deinem Projekt verwenden möchtest, ähnlich wie das Plugin `@studiocms/blog`, kannst du eine eigene Komponente `Navigation.astro` erstellen:
+
+```astro title="Navigation.astro"
+---
+import { StudioCMSRoutes } from 'studiocms:lib';
+import studioCMS_SDK from 'studiocms:sdk/cache';
+import { frontendNavigation } from 'studiocms:plugin-helpers';
+
+// Definiere die Requisiten für die Komponente Navigation
+interface Props {
+ topLevelLinkCount?: number;
+};
+
+// Erhalte die Anzahl der Links auf oberster Ebene aus den Requisiten
+const { topLevelLinkCount = 3 } = Astro.props;
+
+// Abrufen der Website-Konfiguration und der Seitenliste
+const config = (await studioCMS_SDK.GET.siteConfig()).data;
+
+// Hol dir den Titel der Seite aus der Konfiguration
+const { title } = config || { title: 'StudioCMS' };
+
+// Erhalte die URL der Hauptseite
+const {
+ mainLinks: { baseSiteURL },
+} = StudioCMSRoutes;
+
+// Definiere die Link-Requisiten für die Navigation
+type LinkProps = {
+ text: string;
+ href: string;
+};
+
+// Definiere die Links für die Navigation
+const links: LinkProps[] = await frontendNavigation();
+---
+{/* Wenn keine Dropdown-Elemente */}
+{ ( links.length < topLevelLinkCount || links.length === topLevelLinkCount ) && (
+
+) }
+```
+
+Das obige Beispiel definiert eine benutzerdefinierte Komponente `Navigation.astro`, die die eingebauten StudioCMS-Navigationshilfen verwendet, um ein Navigationsmenü für das Projekt zu erstellen. Die Komponente enthält Links zur Haupt-URL der Website, zur Indexseite und zu allen anderen Seiten, die in der Navigation angezeigt werden sollen.
+
+Du musst nur noch ein paar Stile hinzufügen und schon hast du ein voll funktionsfähiges Navigationsmenü, das mit den eingebauten StudioCMS-Navigationshelfern funktioniert.
diff --git a/src/content/docs/de/plugins/index.mdx b/src/content/docs/de/plugins/index.mdx
new file mode 100644
index 00000000..de0d9e25
--- /dev/null
+++ b/src/content/docs/de/plugins/index.mdx
@@ -0,0 +1,298 @@
+---
+i18nReady: true
+title: Die Grundlagen
+description: Erfahre mehr über die StudioCMS Plugins und wie sie funktionieren.
+sidebar:
+ order: 1
+---
+
+import ReadMore from '~/components/ReadMore.astro'
+
+# Einführung
+
+StudioCMS-Plugins sind ein leistungsstarkes Werkzeug, mit dem du die Funktionalität von StudioCMS erweitern kannst. Sie bieten eine einfache und flexible Möglichkeit, neue Funktionen zu deinem StudioCMS-Projekt hinzuzufügen. Im Folgenden findest du eine Übersicht über die StudioCMS-Plugins und ihre Funktionsweise.
+
+## Was sind Plugins?
+
+StudioCMS-Plugins sind ähnlich wie Astro-Integrationen, aber sie haben zusätzliche Informationen, die an das Funktionsobjekt angehängt sind. Diese Informationen werden von StudioCMS verwendet, um zu bestimmen, wie das Plugin geladen und verwendet werden soll. StudioCMS-Plugins werden verwendet, um die Funktionalität von StudioCMS zu erweitern, indem neue Funktionen hinzugefügt oder bestehende geändert werden.
+
+### Der StudioCMS Plugin-Typ
+
+```ts twoslash
+import { APIRoute, AstroIntegration } from "astro"
+import type { HeroIconName } from '@studiocms/ui/components/Icon/iconType.js';
+import type { SanitizeOptions } from 'ultrahtml/transformers/sanitize';
+import type { SettingsField } from 'studiocms/schemas';
+// ---cut---
+type StudioCMSPlugin = {
+ /**
+ * Kennung des Plugins aus der package.json
+ */
+ identifier: string;
+
+ /**
+ * Bezeichnung des Plugins, die im StudioCMS Dashboard angezeigt werden soll
+ */
+ name: string;
+
+ /**
+ * Erforderliche Mindestversion von StudioCMS, damit das Plugin funktioniert
+ */
+ studiocmsMinimumVersion: string;
+
+ /**
+ * Astro-Integration(en), die das Plugin bietet
+ */
+ integration?: AstroIntegration | AstroIntegration[] | undefined;
+
+ /**
+ * Wenn dies der Fall ist, aktiviert das Plugin die Erstellung der Sitemap
+ */
+ triggerSitemap?: boolean;
+
+ /**
+ * Ermöglicht es dem Plugin, Sitemap-Endpunkte hinzuzufügen
+ */
+ sitemaps?: Array<{
+
+ /**
+ * Name des Plugins
+ */
+ pluginName: string;
+
+ /**
+ * Pfad zur Sitemap-Xml-Endpunktdatei
+ */
+ sitemapXMLEndpointPath: string | URL;
+ }> | undefined;
+
+ /**
+ * Ermöglicht es dem Plugin, benutzerdefinierte Dashboard-Gitterelemente hinzuzufügen
+ */
+ dashboardGridItems?: Array<{
+
+ /**
+ * Name des Gitterelements
+ */
+ name: string;
+
+ /**
+ * Spannweite des Gitterelements
+ */
+ span: 1 | 2 | 3;
+
+ /**
+ * Kartenvariante des Gitterelements
+ */
+ variant: 'default' | 'filled';
+
+ /**
+ * Erlaubnis erforderlich, um das Gitterelement anzuzeigen
+ */
+ requiresPermission?: "owner" | "admin" | "editor" | "visitor";
+
+ /**
+ * Kopfzeileninformationen des Gitterelements
+ */
+ header?: {
+
+ /**
+ * Titel des Gitterelements
+ */
+ title: string;
+
+ /**
+ * Symbol für das Gitterelement
+ */
+ icon?: HeroIconName;
+ };
+
+ /**
+ * Körperinformationen des Gitterelements
+ */
+ body?: {
+
+ /**
+ * HTML-Inhalt des Gitterelements
+ */
+ html: string;
+
+ /**
+ * Komponente, die im Gitterelement angezeigt wird
+ */
+ components?: Record;
+
+ /**
+ * Sanitize-Optionen für den HTML-Inhalt
+ */
+ sanitizeOpts?: SanitizeOptions;
+ };
+ }> | undefined;
+
+ /**
+ * Wenn dies der Fall ist, hat das Plugin seine eigene Einstellungsseite
+ */
+ settingsPage: {
+
+ /**
+ * Felder gemäß Spezifikation
+ */
+ fields: SettingsField[];
+
+ /**
+ * Der Endpunkt für die Einstellungen
+ *
+ * Sollte eine APIRoute namens `onSave` exportieren, die ausgeführt wird, wenn die Einstellungsseite gespeichert wird
+ */
+ endpoint: string,
+ } | undefined;
+
+ /**
+ * Navigationslinks für die Verwendung mit dem `@studiocms/blog`-Plugin und anderen Plugins zur Anzeige von Links im Frontend
+ */
+ frontendNavigationLinks: Array<{
+ label: string;
+ href: string;
+ }>;
+
+ /**
+ * Seitentyp-Definition. Wenn dies der Fall ist, möchte das Plugin den Prozess der Seitenerstellung ändern können
+ */
+ pageTypes: Array<{
+
+ /**
+ * Beschriftung, die in der Select-Eingabe angezeigt wird
+ */
+ label: string;
+
+ /**
+ * Kennung, die in der Datenbank gespeichert wird
+ * @example
+ * // Einzelner Seitentyp pro Plugin
+ * 'studiocms'
+ * '@studiocms/blog'
+ * // Mehrere Seitentypen pro Plugin (verwende eindeutige Bezeichner für jeden Typ, um Konflikte zu vermeiden)
+ * '@mystudiocms/plugin:pageType1'
+ * '@mystudiocms/plugin:pageType2'
+ * '@mystudiocms/plugin:pageType3'
+ * '@mystudiocms/plugin:pageType4'
+ */
+ identifier: string;
+
+ /**
+ * Beschreibung, die unter der Überschrift „Seiteninhalt“ angezeigt wird, wenn dieser Typ ausgewählt ist
+ */
+ description: string;
+
+ /**
+ * Der Pfad zu der eigentlichen Komponente, die für den Seiteninhalt angezeigt wird
+ *
+ * Die Komponente sollte eine Eigenschaft `content` haben, die ein String ist, um den aktuellen Inhalt anzeigen zu können.
+ *
+ * **HINWEIS:** Derzeit musst du die Formular-ID `page-content` für die Inhaltsausgabe verwenden. Dein Editor sollte auch in der Lage sein, die Formularübermittlung zu verarbeiten.
+ *
+ * **HINWEIS:** Du kannst `studiocms/markdown` oder `studiocms/html` als Fallback-Wert verwenden, wenn du mit HTML- oder Markdown-Inhalten arbeitest!
+ *
+ * @example
+ * ```ts
+ * import { createResolver } from 'astro-integration-kit';
+ * const { resolve } = createResolver(import.meta.url)
+ *
+ * {
+ * pageContentComponent: resolve('./components/MyContentEditor.astro'),
+ * }
+ * ```
+ */
+ pageContentComponent: 'studiocms/markdown' | 'studiocms/html' | string;
+
+ /**
+ * Der Pfad zu der tatsächlichen Komponente, die für den Seitenrenderer angezeigt wird
+ *
+ * **HINWEIS:** Du kannst `studiocms/markdown` oder `studiocms/html` als Fallback-Wert verwenden, wenn du mit HTML- oder Markdown-Inhalten arbeitest!
+ */
+ rendererComponent: 'studiocms/markdown' | 'studiocms/html' | string;
+
+ /**
+ * Felder gemäß Spezifikation
+ */
+ fields: SettingsField[];
+
+ /**
+ * API-Endpunktdatei für den Seitentyp
+ *
+ * API-Endpunkte werden verwendet, um Seiten dieses Typs zu erstellen, zu bearbeiten und zu löschen,
+ * Endpunkte erhalten den vollständigen Astro APIContext von der Astro APIRoute.
+ *
+ * Die Datei sollte mindestens einen der folgenden Punkte exportieren:
+ * - `onCreate`
+ * - `onEdit`
+ * - `onDelete`
+ *
+ * @example
+ * ```ts
+ * // my-plugin.ts
+ * import { createResolver } from 'astro-integration-kit';
+ * const { resolve } = createResolver(import.meta.url)
+ *
+ * {
+ * apiEndpoint: resolve('./api/pageTypeApi.ts'),
+ * }
+ *
+ * // api/pageTypeApi.ts
+ * import { APIRoute } from 'astro';
+ *
+ * export const onCreate: APIRoute = async (ctx) => {
+ * // Custom logic here
+ * return new Response();
+ * }
+ * ```
+ */
+ apiEndpoint: string;
+ }> | undefined;
+};
+```
+
+### Ein Plugin definieren
+
+Um ein StudioCMS-Plugin zu definieren, musst du ein Objekt erstellen, das dem Typ `StudioCMSPlugin` entspricht. Dieses Objekt sollte ähnlich wie das folgende aussehen, wobei du beachten musst, dass die folgenden Eigenschaften erforderlich sind:
+
+- `identifier`: Der Bezeichner des Plugins aus der package.json-Datei.
+- `name`: Die Bezeichnung des Plugins, die im StudioCMS Dashboard angezeigt werden soll.
+- `studiocmsMinimumVersion`: Die Mindestversion von StudioCMS, die benötigt wird, damit das Plugin funktioniert.
+
+Hier ist ein Beispiel für eine StudioCMS-Plugin-Definition, die alle erforderlichen Eigenschaften enthält und eine Astro-Integration für eigene Logik bereitstellt:
+
+```ts twoslash title="my-plugin.ts"
+import { definePlugin } from 'studiocms/plugins';
+import { AstroIntegration } from 'astro';
+
+// Definiere die Optionen für das Plugin und die Integration
+interface Options {
+ foo: string;
+}
+
+// Definiere die Astro-Integration
+const myIntegration = (options: Options): AstroIntegration => ({
+ name: 'my-astro-integration',
+ hooks: {
+ "astro:config:setup": () => {
+ console.log('Hello from my Astro Integration!');
+ }
+ }
+});
+
+// Definiere das StudioCMS-Plugin
+export const myPlugin = (options: Options) => definePlugin({
+ identifier: 'my-plugin',
+ name: 'My Plugin',
+ studiocmsMinimumVersion: '0.1.0-beta.8',
+ integration: myIntegration(options), // Optional, aber empfohlen
+});
+```
+
+In diesem Beispiel definieren wir ein StudioCMS-Plugin namens `My Plugin`, das StudioCMS Version `0.1.0-beta.8` oder höher benötigt. Das Plugin stellt außerdem eine Astro-Integration bereit, die eine Meldung auf der Konsole protokolliert, wenn der `astro:config:setup`-Hook aufgerufen wird.
+
+Weitere Informationen zur Erstellung von Plugins findest du in der [„Plugins nützlich machen“][extended-plugins]-Anleitung.
+
+{/* Links */}
+[extended-plugins]: /de/plugins/extended/
\ No newline at end of file
diff --git a/src/content/docs/de/start-here/configuration.mdx b/src/content/docs/de/start-here/configuration.mdx
new file mode 100644
index 00000000..ff511954
--- /dev/null
+++ b/src/content/docs/de/start-here/configuration.mdx
@@ -0,0 +1,87 @@
+---
+i18nReady: true
+title: "StudioCMS-Konfiguration"
+description: "Optionen für die Definition der StudioCMS-Konfiguration"
+sidebar:
+ order: 3
+---
+
+import { FileTree } from '@astrojs/starlight/components';
+import ReadMore from '~/components/ReadMore.astro';
+
+# Verfügbare Optionen
+
+Es gibt zwei Möglichkeiten, die StudioCMS-Integration zu konfigurieren. Im Folgenden findest du Beispiele für die Konfiguration, je nachdem, ob du die Datei `astro.config.mjs` oder die spezielle Datei `studiocms.config.mjs` verwendest
+
+
+Diese Seite zeigt dir, wie und wo du die StudioCMS-Konfiguration definieren kannst. Weitere Informationen zu den StudioCMS-Konfigurationsoptionen findest du auf der [Referenzseite][reference-page].
+
+
+## Verwendung der Datei `astro.config.mjs`:
+
+```ts twoslash title="astro.config.mjs"
+import db from '@astrojs/db';
+import node from '@astrojs/node';
+import studioCMS from 'studiocms';
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+ site: 'https://demo.studiocms.dev/',
+ output: 'server',
+ adapter: node({ mode: "standalone" }),
+ integrations: [
+ db(),
+ studioCMS({
+ dbStartPage: false,
+ // ...AndereKonfigurationsOptionen
+ }),
+ ],
+});
+```
+
+## Verwendung der Datei `studiocms.config.mjs` (empfohlen):
+
+Wenn du dich für diese Option entscheidest, musst du sicherstellen, dass du alle StudioCMS-Konfigurationsoptionen in diese Datei verschiebst (siehe unten):
+
+### Beispiel Dateistruktur
+
+
+
+- .env
+- astro.config.mjs
+- **studiocms.config.mjs**
+- studiocms-auth.config.json Automatisch generieren
+- package.json
+- src
+ - env.d.ts
+ - ...
+
+
+
+### Beispiel-Konfiguration
+
+```ts twoslash title="astro.config.mjs"
+import db from '@astrojs/db';
+import node from '@astrojs/node';
+import studioCMS from 'studiocms';
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+ site: 'https://demo.studiocms.dev/',
+ output: 'server',
+ adapter: node({ mode: "standalone" }),
+ integrations: [ db(), studioCMS() ],
+});
+```
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from "studiocms/config";
+
+export default defineStudioCMSConfig({
+ dbStartPage: false,
+ // ...AndereKonfigurationsOptionen
+})
+```
+
+{/* Links */}
+[reference-page]: /de/config-reference/
\ No newline at end of file
diff --git a/src/content/docs/de/start-here/environment-variables.mdx b/src/content/docs/de/start-here/environment-variables.mdx
new file mode 100644
index 00000000..9849583c
--- /dev/null
+++ b/src/content/docs/de/start-here/environment-variables.mdx
@@ -0,0 +1,112 @@
+---
+i18nReady: true
+title: Umgebungsvariablen
+description: Ein kurzer Überblick über die in StudioCMS verwendeten Umgebungsvariablen.
+sidebar:
+ order: 2
+---
+
+import { Aside } from '@astrojs/starlight/components';
+import ReadMore from '~/components/ReadMore.astro';
+
+Damit StudioCMS richtig funktioniert, musst du die richtigen Umgebungsvariablen einrichten. Diese Variablen sind wichtig, um eine sichere Verbindung zu Astro DB herzustellen und sich bei der StudioCMS-API zu authentifizieren. Wenn du diese Umgebungsvariablen nicht richtig konfigurierst, wird die Anwendung nicht wie vorgesehen funktionieren.
+
+Du kannst eine `.env`-Datei im Hauptverzeichnis deines Projekts erstellen und die benötigten Umgebungsvariablen hinzufügen. Die Datei `.env` ist eine Textdatei, die Schlüssel-Wert-Paare von Umgebungsvariablen enthält. Die Umgebungsvariablen werden von der Anwendung zur Laufzeit gelesen.
+
+Wie du in Zukunft mit Umgebungsvariablen in Astro arbeitest, kannst du unter [Umgebungsvariablen](https://docs.astro.build/de/guides/environment-variables/) in der Astro-Dokumentation nachlesen.
+
+## Erforderliche Umgebungsvariablen
+
+Um StudioCMS nutzen zu können, musst du einige Umgebungsvariablen in deiner `.env`-Datei einrichten.
+
+### Datenbank URL und Token für `@astrojs/db`
+
+`ASTRO_DB_REMOTE_URL` - Die Verbindungs-URL zu deinem libSQL-Server
+`ASTRO_DB_APP_TOKEN` - Das App-Token für deinen libSQL-Server
+
+```bash title=".env"
+ASTRO_DB_REMOTE_URL=libsql://your.server.io
+ASTRO_DB_APP_TOKEN=eyJh...RUCg
+```
+
+Weitere Informationen zu `@astrojs/db` findest du in der [Astro-Dokumentation für Astro DB](https://docs.astro.build/en/guides/astro-db/)
+
+### Verschlüsselungsschlüssel für `@studiocms/auth`
+
+`CMS_ENCRYPTION_KEY` - Ein sicherer Verschlüsselungsschlüssel zum Verschlüsseln sensibler Daten
+
+```bash title=".env"
+CMS_ENCRYPTION_KEY="wqR+w...sRcg=="
+```
+
+
+
+## Optionale Umgebungsvariablen
+
+### oAuth Authentifizierung Umgebungsvariablen
+
+
+Weitere Informationen zum Einrichten der oAuth-Authentifizierung findest du in der [„oAuth-Authentifizierung konfigurieren“][config-oauth]-Dokumentation.
+
+
+#### GitHub (Optional)
+
+Um dich bei GitHub zu authentifizieren, musst du die folgenden Umgebungsvariablen zu deiner `.env`-Datei hinzufügen:
+
+```bash title=".env"
+# Anmeldeinformationen für GitHub OAuth
+CMS_GITHUB_CLIENT_ID=
+CMS_GITHUB_CLIENT_SECRET=
+CMS_GITHUB_REDIRECT_URI=
+```
+
+
+
+#### Discord (Optional)
+
+```bash title=".env"
+# Anmeldeinformationen für Discord OAuth
+CMS_DISCORD_CLIENT_ID=
+CMS_DISCORD_CLIENT_SECRET=
+CMS_DISCORD_REDIRECT_URI=
+```
+
+#### Google (Optional)
+
+```bash title=".env"
+# Anmeldeinformationen für Google OAuth
+CMS_GOOGLE_CLIENT_ID=
+CMS_GOOGLE_CLIENT_SECRET=
+CMS_GOOGLE_REDIRECT_URI=
+```
+
+#### Auth0 (Optional)
+
+```bash title=".env"
+# Anmeldeinformationen für auth0 OAuth
+CMS_AUTH0_CLIENT_ID=
+CMS_AUTH0_CLIENT_SECRET=
+CMS_AUTH0_DOMAIN=
+CMS_AUTH0_REDIRECT_URI=
+```
+
+### Umgebungsvariablen für den Image Handler
+
+#### Cloudinary (Optional)
+
+Wenn du dich entscheidest, das integrierte Cloudinary-Plugin zu verwenden, musst du Folgendes definieren:
+
+```bash title=".env"
+## Cloudinary Javascript SDK
+CMS_CLOUDINARY_CLOUDNAME="demo"
+```
+
+{/* Links */}
+[config-oauth]: /de/start-here/getting-started/#optional-konfiguriere-die-oauth-authentifizierung
\ No newline at end of file
diff --git a/src/content/docs/de/start-here/gallery.mdx b/src/content/docs/de/start-here/gallery.mdx
new file mode 100644
index 00000000..23650a48
--- /dev/null
+++ b/src/content/docs/de/start-here/gallery.mdx
@@ -0,0 +1,15 @@
+---
+i18nReady: true
+title: Galerie
+description: Eine kleine Galerie mit Bildern, um StudioCMS vorzustellen
+tableOfContents: false
+sidebar:
+ order: 5
+---
+
+import Gallery from '~/components/Gallery.astro'
+import { mainDemoGalleryImages } from "~/assets/index.ts"
+
+Dies ist eine kleine Galerie mit Bildern, die die StudioCMS-Integration zeigen.
+
+
diff --git a/src/content/docs/de/start-here/getting-started.mdx b/src/content/docs/de/start-here/getting-started.mdx
new file mode 100644
index 00000000..4df3bf37
--- /dev/null
+++ b/src/content/docs/de/start-here/getting-started.mdx
@@ -0,0 +1,365 @@
+---
+i18nReady: true
+title: Erste Schritte
+description: Beginne mit der Erstellung von StudioCMS.
+sidebar:
+ order: 1
+---
+
+import { PackageManagers } from 'starlight-package-managers'
+import TursoCLI from '~/components/TursoCLI.astro';
+import { Aside, Steps, Tabs, TabItem } from '@astrojs/starlight/components';
+import ReadMore from '~/components/ReadMore.astro';
+import { sponsors, SponsorLink } from '~/share-link'
+
+## Los geht's
+
+Um StudioCMS zu benutzen, brauchst du:
+
+- Eine von [Astro unterstützte Version von Node.js](https://docs.astro.build/de/install-and-setup/#prerequisites) (Bun und Deno werden nicht unterstützt)
+- Ein Astro-Projekt
+- Ein libSQL-Anbieter oder ein selbst gehosteter libSQL-Server
+- Die StudioCMS-Integration
+
+## Bereite deine Datenbank vor
+
+StudioCMS verwendet `@astrojs/db`, um sich mit deiner libSQL-Datenbank zu verbinden. Du kannst jeden libSQL-Anbieter oder einen selbst gehosteten libSQL-Server verwenden.
+
+Wenn du die StudioCMS CLI verwendest, kannst du diesen Schritt überspringen und die CLI verwenden, um eine neue Datenbank zu erstellen, wenn du die Turso CLI installiert hast.
+
+Weitere Informationen zu den erforderlichen Umgebungsvariablen findest du unter [Datenbank-URL und Token für `@astrojs/db`][db-url-token].
+
+### Erste Schritte mit Turso
+
+
+
+
+1. Installiere das
+2. bei Turso.
+3. Erstelle eine neue Datenbank.
+
+4. Erhalte und setze `ASTRO_DB_REMOTE_URL`
+
+ 4a. Führe den Befehl `show` aus, um Informationen über die neu erstellte Datenbank zu erhalten:
+
+
+ 4b. Kopiere den URL-Wert und setze ihn als Wert für `ASTRO_DB_REMOTE_URL`.
+ ```bash title=".env"
+ ASTRO_DB_REMOTE_URL=libsql://studiocms-yourname.turso.io
+ ```
+
+5. Erhalte und setze `ASTRO_DB_APP_TOKEN`
+
+ 5a. Erstelle ein neues Token, um Anfragen an die Datenbank zu authentifizieren:
+
+
+ 5b. Kopiere die Ausgabe des Befehls und setze sie als Wert für `ASTRO_DB_APP_TOKEN`.
+ ```bash title=".env"
+ ASTRO_DB_APP_TOKEN=eyJhbGciOiJF...3ahJpTkKDw
+ ```
+
+
+
+Jetzt kannst du mit der Einrichtung deines StudioCMS-Projekts fortfahren!
+
+### Verwendung eines anderen Anbieters oder einer selbst gehosteten libSQL
+
+libSQL unterstützt sowohl HTTP als auch WebSockets als Transportprotokoll für einen entfernten Server. Sie unterstützt auch die Verwendung einer lokalen Datei oder einer In-Memory-DB.
+
+Weitere Informationen zu den erforderlichen Umgebungsvariablen findest du unter [Datenbank-URL und Token für `@astrojs/db`][db-url-token].
+
+Weitere Informationen zu allen möglichen libSQL-Optionen (einschließlich lokaler Dateien) findest du unter [den Astro Dokumentationen: Optionen zur Konfiguration der Remote-URL].(https://docs.astro.build/de/guides/astro-db/#remote-url-configuration-options)
+
+## Erstelle ein StudioCMS-Projekt
+
+
+
+
+
+ 1. Erstellen eines StudioCMS-Projekts mit dem Befehl create
+
+ Um mit StudioCMS ein neues Astro-Projekt mit einer unserer vorgefertigten Vorlagen zu erstellen, führst du einfach den folgenden Befehl in deinem Terminal aus:
+
+
+
+ Nachdem du den Befehl ausgeführt hast, wirst du aufgefordert, ein paar Fragen zu deinem Projekt zu beantworten. Danach erstellt das CLI ein neues Astro-Projekt mit StudioCMS im angegebenen Verzeichnis.
+
+ Danach wirst du aufgefordert, die nächsten Schritte zu befolgen. Dazu gehört, dass du sicherstellst, dass deine Umgebungsvariablen richtig gesetzt sind und dass du das Projekt ausführst, um die Einrichtung abzuschließen.
+
+ 2. Nachdem du das CLI ausgeführt hast, vergewissere dich, dass deine `astro.config.mjs`-Datei richtig konfiguriert ist:
+
+ ```ts twoslash title="astro.config.mjs" {2-4,11-12}
+ import { defineConfig } from 'astro/config';
+ import db from '@astrojs/db';
+ import node from '@astrojs/node';
+ import studioCMS from 'studiocms';
+
+ export default defineConfig({
+ site: 'https://demo.studiocms.dev/',
+ output: 'server',
+ adapter: node({ mode: "standalone" }),
+ integrations: [
+ db(),
+ studioCMS(),
+ ],
+ });
+ ```
+
+
+
+
+
+ {/* Note: For some reason this breaks placement of EC-Twoslash popups... must investigate */}
+
+ 1. Erstellen eines neuen Astro-Projekts
+
+ Um ein neues Astro-Projekt zu erstellen, führst du einfach den folgenden Befehl in deinem Terminal aus:
+
+
+
+ Nachdem du den Befehl ausgeführt hast, wirst du aufgefordert, ein paar Fragen zu deinem Projekt zu beantworten. Danach erstellt das CLI ein neues Astro-Projekt im angegebenen Verzeichnis.
+
+ Du solltest die Meldung „Liftoff confirmed. Explore your project!“, gefolgt von einigen empfohlenen nächsten Schritten.
+
+ `cd` in dein neues Projektverzeichnis, um Astro zu verwenden.
+
+ ```bash
+ cd my-project
+ ```
+
+ Wenn du den npm-Installationsschritt während des CLI-Assistenten übersprungen hast, musst du deine Abhängigkeiten installieren, bevor du fortfährst.
+
+ 2. Um die StudioCMS-Integration zu deinem Projekt hinzuzufügen, musst du das StudioCMS-Paket und seine Abhängigkeiten installieren:
+
+
+
+ 3. Stelle nach der Installation des Pakets sicher, dass deine Datei `astro.config.mjs` die Integration korrekt importiert und aufruft:
+
+ ```ts twoslash title="astro.config.mjs" {2-4,11-12}
+ import { defineConfig } from 'astro/config';
+ import db from '@astrojs/db';
+ import node from '@astrojs/node';
+ import studioCMS from 'studiocms';
+
+ export default defineConfig({
+ site: 'https://demo.studiocms.dev/',
+ output: 'server',
+ adapter: node({ mode: "standalone" }),
+ integrations: [
+ db(),
+ studioCMS(),
+ ],
+ });
+ ```
+
+ {/* */}
+
+
+
+
+
+ {/* */}
+
+ 1. Erstellen eines neuen Astro-Projekts
+
+ Um ein neues Astro-Projekt zu erstellen, führst du einfach den folgenden Befehl in deinem Terminal aus:
+
+
+
+ Nachdem du den Befehl ausgeführt hast, wirst du aufgefordert, ein paar Fragen zu deinem Projekt zu beantworten. Danach erstellt das CLI ein neues Astro-Projekt im angegebenen Verzeichnis.
+
+ Du solltest die Meldung „Liftoff confirmed. Explore your project!“, gefolgt von einigen empfohlenen nächsten Schritten.
+
+ `cd` in dein neues Projektverzeichnis, um Astro zu verwenden.
+
+ ```bash
+ cd my-project
+ ```
+
+ Wenn du den npm-Installationsschritt während des CLI-Assistenten übersprungen hast, musst du deine Abhängigkeiten installieren, bevor du fortfährst.
+
+ 2. Um die StudioCMS-Integration in dein Projekt zu integrieren, musst du das Astro StudioCMS-Paket und seine Abhängigkeiten installieren:
+
+
+
+ 3. Aktualisiere deine `astro.config.mjs`-Datei:
+
+ ```ts twoslash title="astro.config.mjs" {2-4,11-12}
+ import { defineConfig } from 'astro/config';
+ import db from '@astrojs/db';
+ import node from '@astrojs/node';
+ import studioCMS from 'studiocms';
+
+ export default defineConfig({
+ site: 'https://demo.studiocms.dev/',
+ output: 'server',
+ adapter: node({ mode: "standalone" }),
+ integrations: [
+ db(),
+ studioCMS(),
+ ],
+ });
+ ```
+ {/* */}
+
+
+
+
+
+Bitte beachte, dass die Option `site` in der Datei `astro.config.mjs` erforderlich ist, damit StudioCMS korrekt funktioniert. Du kannst hier die URL deiner Website oder eine Platzhalter-URL angeben. (z.B. `https://demo.studiocms.xyz/` oder `http://localhost:4321/`)
+
+
+
+## Authentifizierung konfigurieren
+
+StudioCMS Auth benötigt mindestens den [Encryption Key][encryption-key], der in deiner `.env` Datei gesetzt sein muss.
+
+Die folgenden Umgebungsvariablen sind für die StudioCMS-Authentifizierung erforderlich:
+
+```bash title=".env"
+# Verschlüsselungsschlüssel für die Authentifizierung mit Benutzernamen und Passwort
+CMS_ENCRYPTION_KEY="wqR+w...sRcg=="
+```
+
+Du kannst einen sicheren Verschlüsselungsschlüssel mit dem folgenden Befehl erzeugen:
+
+```bash
+openssl rand --base64 16
+```
+
+Und setze die Ausgabe als Wert für `CMS_ENCRYPTION_KEY`.
+
+
+Weitere Informationen über alle verfügbaren Umgebungsvariablen für die Authentifizierung findest du auf der Seite [Umgebungsvariablen][environment-variables].
+
+
+### Optional: Konfiguriere die oAuth-Authentifizierung
+
+StudioCMS unterstützt die oAuth-Authentifizierung mit GitHub, Discord, Google und Auth0. Um die oAuth-Authentifizierung zu konfigurieren, musst du die [erforderlichen Umgebungsvariablen in deiner `.env`-Datei][oauth-environment-variables] setzen und sicherstellen, dass der Provider [in deiner Konfiguration][auth-config-ref] aktiviert ist.
+
+Um oAuth-Anbieter einzurichten, benötigen sie eine Callback-URL. Die Callback-URL ist der Pfad, an den der Anbieter den Nutzer nach der Authentifizierung weiterleiten wird.
+
+#### Einrichten der Callback-URL
+
+Die Callback-URL sollte je nach deiner Umgebung auf einen der folgenden Pfade gesetzt werden:
+
+| Umgebung | Callback-URL |
+|---------------|--------------|
+| Produktion | `https://your-domain.tld/studiocms_api/auth//callback` |
+| Testen & Entwickelung | `http://localhost:4321/studiocms_api/auth//callback` |
+
+#### Beispiel für Callback-URL-Pfade
+
+Die folgenden Pfade sind Beispiele für die Callback-URL für jeden Anbieter:
+
+| Anbieter | Callback-Pfad |
+|----------|---------------|
+| GitHub | `/studiocms_api/auth/github/callback` |
+| Discord | `/studiocms_api/auth/discord/callback` |
+| Google | `/studiocms_api/auth/google/callback` |
+| Auth0 | `/studiocms_api/auth/auth0/callback` |
+
+## Konfiguriere deine `package.json`-Skripte
+
+Richte deine `package.json`-Skripte so ein, dass sie das `--remote`-Flag für Build und optional für die Entwicklung enthalten. (Du kannst den Entwicklungsbefehl auch so ausführen, wie im Abschnitt [„Ausführen deines StudioCMS-Projekts“](#ausführen-deines-studiocms-projekts) gezeigt).
+
+```json /--remote/ title="package.json"
+{
+ "name": "my-studiocms-project",
+ "scripts": {
+ "dev": "astro dev --remote",
+ "build": "astro check & astro build --remote",
+ "astro": "astro"
+ }
+}
+```
+
+## Ausführen deines StudioCMS-Projekts
+
+Dank der Leistungsfähigkeit von Astro ist der Betrieb von StudioCMS so einfach wie das Ausführen des Entwickelungsbefehls für die lokale Vorschau oder das Erstellen und Bereitstellen auf deinem Server.
+
+### Erstmalige Einrichtung (oder bei Aktualisierungen, wenn das Tabellenschema aktualisiert wird)
+
+Um dein Astro-Projekt zu starten, führe die folgenden Befehle in deinem Terminal aus:
+
+
+
+
+
+
+Nachdem du die Befehle ausgeführt hast, solltest du eine Meldung sehen, die besagt, dass dein Projekt unter `localhost:4321` läuft. Wenn du StudioCMS zum ersten Mal einrichtest, wirst du aufgefordert, die Konfiguration von StudioCMS unter `http://localhost:4321/start` abzuschließen.
+
+### Lokale Ausführung im Astro-Entwicklungsmodus
+
+Um dein Astro-Projekt zu starten, führe den folgenden Befehl in deinem Terminal aus:
+
+
+
+Nachdem du den Befehl ausgeführt hast, solltest du eine Meldung sehen, die besagt, dass dein Projekt unter `localhost:4321` läuft. Öffne deinen Browser und navigiere zu `http://localhost:4321`, um dein Astro-Projekt in Aktion zu sehen.
+
+**Glückwunsch!** 🥳 Du hast jetzt StudioCMS in deinem Astro-Projekt installiert.
+
+### Hinzufügen eines Frontends zu deinem StudioCMS-Projekt
+
+StudioCMS ist ein Headless Astro CMS, d.h. du musst dein eigenes Frontend bereitstellen, um die Inhalte anzuzeigen. Wenn du ein bereits fertiges Frontend suchst, kannst du unsere Plugins im [Paket-Katalog][package-catalog] ausprobieren.
+
+#### Einen Blog einrichten
+
+Wenn du einen Blog einrichten möchtest, kannst du das Plugin `@studiocms/blog` verwenden.
+
+Um das Blog-Plugin zu installieren und einzurichten, führe den folgenden Befehl in deinem Terminal aus:
+
+
+
+Nachdem du das Plugin installiert hast, musst du es zu deiner Datei `studiocms.config.mjs` hinzufügen:
+
+```ts twoslash title="studiocms.config.mjs"
+import { defineStudioCMSConfig } from 'studiocms/config';
+import blog from '@studiocms/blog';
+
+export default defineStudioCMSConfig({
+ dbStartPage: false,
+ plugins: [
+ blog(),
+ ],
+});
+```
+
+### Erstellen und Bereitstellen deines StudioCMS-Projekts
+
+Nachdem du die [Schritte für die Ersteinrichtung](#erstmalige-einrichtung-oder-bei-aktualisierungen-wenn-das-tabellenschema-aktualisiert-wird) ausgeführt hast, solltest du dein StudioCMS-Projekt erstellen und auf deinem Server bereitstellen.
+
+Standardmäßig ist das Dashboard von StudioCMS unter `http://your-domain.tld/dashboard` verfügbar.
+
+Dieses Dashboard steht dir zur Verfügung, um deine Inhalte und Einstellungen im Entwicklungs- und Produktionsmodus zu verwalten.
+
+Es wird empfohlen, StudioCMS nur im Produktionsmodus zu verwenden, da das Dashboard für das erstellte Projekt gedacht ist. (Im Entwicklungsmodus können einige Probleme/Fehler auftreten, z. B. ein Vite Entwicklungsfehler).
+
+## Nächste Schritte
+
+
+Hier erfährst du, wie du [Umgebungsvariablen][environment-variables] in StudioCMS einstellst.
+
+
+
+Schau dir den [Paketkatalog][package-catalog] an, um Plugins mit StudioCMS zu finden und zu verwenden.
+
+
+
+Mehr über die StudioCMS-Konfigurationsoptionen erfährst du auf den Seiten [StudioCMS Referenz][config-reference].
+
+
+{/* Links */}
+[package-catalog]: /de/package-catalog/
+[environment-variables]: /de/start-here/environment-variables/
+[config-reference]: /de/config-reference/
+[db-url-token]: /de/start-here/environment-variables/#datenbank-url-und-token-für-astrojsdb
+[encryption-key]: /de/start-here/environment-variables/#verschlüsselungsschlüssel-für-studiocmsauth
+[oauth-environment-variables]: /de/start-here/environment-variables/#oauth-authentifizierung-umgebungsvariablen
+[auth-config-ref]: /de/config-reference/dashboard/#authconfig
\ No newline at end of file
diff --git a/src/content/docs/de/start-here/why-studioCMS.mdx b/src/content/docs/de/start-here/why-studioCMS.mdx
new file mode 100644
index 00000000..464d8111
--- /dev/null
+++ b/src/content/docs/de/start-here/why-studioCMS.mdx
@@ -0,0 +1,30 @@
+---
+i18nReady: true
+title: Warum StudioCMS?
+description: StudioCMS ist eine Alternative zu herkömmlichen CMS-Plattformen. Es ist ein Headless CMS, das auf Astro DB und Astro basiert, um ein nahtloses Content Management zu ermöglichen.
+sidebar:
+ order: 4
+---
+
+Astro ist ein inhaltsorientiertes Framework. Funktionen wie Inhaltssammlungen und die neue Inhaltsebene machen es extrem einfach, Inhalte jeder Größe und Form zu verwalten.
+
+Allerdings ist es auch eine Lösung, für die du im Grunde genommen ein Entwickler sein musst oder zumindest über ein angemessenes Maß an Wissen darüber verfügen musst, wie Astro die Dateien verwendet, die du in deinem Inhaltsverzeichnis abgelegt hast. Außerdem kannst du die Erfahrung, die Astro bietet, nicht einem Kunden oder einer Person präsentieren, die einfach nur Inhalte verwalten möchte. Dafür brauchst du ein CMS.
+
+Es gibt viele CMS mit unterschiedlichen Ausprägungen und Funktionen für deine Bedürfnisse, aber keines, das alle Möglichkeiten von Astro vollständig ausschöpft.
+Deshalb gibt es StudioCMS: ein CMS, das sich ganz auf Astro konzentriert und das jede einzelne seiner Funktionen nutzen kann, um einen stark verbesserten DX zu bieten.
+
+## Hauptmerkmale
+
+- **`@astrojs/db`:** Wir verwenden Astro DB, d.h. du kannst wählen, wo und wie deine Daten gespeichert werden, ob in Turso oder in einer lokalen Datei.
+
+- **Benutzerdefinierter Markdown-Renderer:** Eingebauter Markdown-Renderer mit Unterstützung für gethemete Callouts und anpassbarem Styling, um deine Bedürfnisse zu erfüllen.
+
+- **Eingebaute Authentifizierung:** Umfassendes Authentifizierungssystem mit integrierter Unterstützung für Passwortverschlüsselung, Sitzungsmanagement, Ratenbegrenzung und anpassbare Berechtigungsstufen.
+
+- **WordPress-Importer:** Es ist ganz einfach, von jeder Standard-WordPress-Installation zu StudioCMS zu wechseln!
+
+- **Plugin-System:** Erweiterbare Plugin-Architektur, die benutzerdefinierte Seitentypen, Dashboard-Widgets und Einstellungsseiten ermöglicht.
+
+- **Rendering von Inhalten:** Integrierte Unterstützung für anpassbare Inhaltswiedergabe mit Funktionen wie thematischen Callouts und Markdown-Styling.
+
+- **Mehr in der Zukunft:** StudioCMS wird derzeit aktiv weiterentwickelt! Wir werden im Laufe der Zeit weitere Funktionen hinzufügen, um deine Inhalte noch reibungsloser zu gestalten! Wenn du Vorschläge oder Feedback hast, [öffne ein GitHub Issue](https://github.com/withstudiocms/studiocms/issues/new/choose)!
diff --git a/src/content/docs/de/utils/rendering.mdx b/src/content/docs/de/utils/rendering.mdx
new file mode 100644
index 00000000..44506e23
--- /dev/null
+++ b/src/content/docs/de/utils/rendering.mdx
@@ -0,0 +1,39 @@
+---
+i18nReady: true
+title: "Rendering-Inhalt"
+description: "Optionen für das Rendern von Inhalten"
+sidebar:
+ order: 1
+---
+
+Das StudioCMS-Rendering-System ist dynamisch und basiert auf dem aktuellen PageType.
+
+Beispiel Catch-All-Route, bei der die aktuelle Seite aus dem SDK geholt und die Seitendaten an den Renderer übergeben werden. In diesem Fall verwenden wir den in den Seiteneinstellungen konfigurierten Standard-Seitentyp `studiocms/markdown` und verpacken diesen in ein Layout, wie wir es mit dem Plugin `@studiocms/blog` tun. ein pageBuilder-Plugin kann zum Beispiel ohne ein Standard-Layout geliefert werden, sondern sieht vor, dass du das Ganze innerhalb des Builders gestaltest, wie du es bei anderen CMS-Systemen tun würdest.
+
+```astro title="src/pages/[...slug].astro"
+---
+import { StudioCMSRenderer } from 'studiocms:renderer';
+import studioCMS_SDK from 'studiocms:sdk';
+import Layout from '../layouts/Layout.astro';
+
+let { slug } = Astro.params;
+
+if (!slug) {
+ slug = 'index';
+}
+
+const page = await studioCMS_SDK.GET.databaseEntry.pages.bySlug(slug);
+
+if (!page) {
+ return Astro.redirect('/404');
+}
+
+const { title, description, heroImage } = page;
+---
+
+
+
+
+
+
+```
\ No newline at end of file