@umami/shiso 1.17.0 → 1.19.0

package/src/components/docs/Tree.tsx

@@ -14,6 +14,7 @@ import {
   Folder as FolderIcon,
   FolderOpen,
 } from '@/components/icons';
+import { useLabels } from '@/lib/label-context';
 import { styles } from './styles';
 
 export interface TreeFolderProps {
@@ -208,6 +209,7 @@ function visibleFocusables(root: HTMLElement): HTMLElement[] {
 }
 
 function TreeRoot({ children, style, className }: TreeProps) {
+  const labels = useLabels();
   const rootRef = useRef<HTMLDivElement>(null);
   const searchRef = useRef({ text: '', timer: 0 });
 
@@ -334,7 +336,7 @@ function TreeRoot({ children, style, className }: TreeProps) {
       onKeyDown={onKeyDown}
     >
       {/* biome-ignore lint/a11y/noNoninteractiveElementToInteractiveRole: tree is the required ARIA role for this widget */}
-      <ul role="tree" aria-label="File tree" className={styles.treeList}>
+      <ul role="tree" aria-label={labels.fileTree} className={styles.treeList}>
         {content}
       </ul>
     </div>

package/src/components/docs/ZoomableImage.tsx

@@ -1,5 +1,6 @@
 import type { ImgHTMLAttributes } from 'react';
 import { Dialog, DialogContent, DialogTitle, DialogTrigger } from '@/components/ui/dialog';
+import { useLabels } from '@/lib/label-context';
 import { cn } from '@/lib/utils';
 
 export interface ZoomableImageProps extends ImgHTMLAttributes<HTMLImageElement> {
@@ -13,6 +14,7 @@ export function ZoomableImage({
   src,
   ...props
 }: ZoomableImageProps) {
+  const labels = useLabels();
   const image = (
     <img
       {...props}
@@ -26,7 +28,7 @@ export function ZoomableImage({
     return image;
   }
 
-  const label = alt ? `View “${alt}” full size` : 'View image full size';
+  const label = alt ? labels.viewNamedImage.replace('{alt}', () => alt) : labels.viewImage;
 
   return (
     <Dialog>
@@ -47,7 +49,7 @@ export function ZoomableImage({
         overlayClassName="bg-black/80 supports-backdrop-filter:backdrop-blur-sm"
         className="flex max-h-[calc(100vh-2rem)] w-auto max-w-[calc(100vw-2rem)] items-center justify-center bg-transparent p-0 ring-0 shadow-none sm:max-w-[calc(100vw-2rem)]"
       >
-        <DialogTitle className="sr-only">{alt || 'Full-size image'}</DialogTitle>
+        <DialogTitle className="sr-only">{alt || labels.fullSizeImage}</DialogTitle>
         <img
           src={src}
           srcSet={props.srcSet}

package/src/components/ui/dialog.tsx

@@ -2,6 +2,7 @@ import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
 import { XIcon } from 'lucide-react';
 import type * as React from 'react';
 import { Button } from '@/components/ui/button';
+import { useLabels } from '@/lib/label-context';
 import { cn } from '@/lib/utils';
 
 function Dialog({ ...props }: DialogPrimitive.Root.Props) {
@@ -43,6 +44,7 @@ function DialogContent({
   showCloseButton?: boolean;
   overlayClassName?: string;
 }) {
+  const labels = useLabels();
   return (
     <DialogPortal>
       <DialogOverlay className={overlayClassName} />
@@ -61,7 +63,7 @@ function DialogContent({
             render={<Button variant="ghost" className="absolute top-2 right-2" size="icon-sm" />}
           >
             <XIcon />
-            <span className="sr-only">Close</span>
+            <span className="sr-only">{labels.close}</span>
           </DialogPrimitive.Close>
         )}
       </DialogPrimitive.Popup>
@@ -83,6 +85,7 @@ function DialogFooter({
 }: React.ComponentProps<'div'> & {
   showCloseButton?: boolean;
 }) {
+  const labels = useLabels();
   return (
     <div
       data-slot="dialog-footer"
@@ -94,7 +97,9 @@ function DialogFooter({
     >
       {children}
       {showCloseButton && (
-        <DialogPrimitive.Close render={<Button variant="outline" />}>Close</DialogPrimitive.Close>
+        <DialogPrimitive.Close render={<Button variant="outline" />}>
+          {labels.close}
+        </DialogPrimitive.Close>
       )}
     </div>
   );

package/src/components/ui/sheet.tsx

@@ -1,4 +1,6 @@
-'use client';
+import { useLabels } from '@/lib/label-context';
+
+('use client');
 
 import { Dialog as SheetPrimitive } from '@base-ui/react/dialog';
 import { XIcon } from 'lucide-react';
@@ -45,6 +47,7 @@ function SheetContent({
   side?: 'top' | 'right' | 'bottom' | 'left';
   showCloseButton?: boolean;
 }) {
+  const labels = useLabels();
   return (
     <SheetPortal>
       <SheetOverlay />
@@ -64,7 +67,7 @@ function SheetContent({
             render={<Button variant="ghost" className="absolute top-3 right-3" size="icon-sm" />}
           >
             <XIcon />
-            <span className="sr-only">Close</span>
+            <span className="sr-only">{labels.close}</span>
           </SheetPrimitive.Close>
         )}
       </SheetPrimitive.Popup>

package/src/lib/label-context.tsx

@@ -0,0 +1,7 @@
+import { createContext, useContext } from 'react';
+import { englishLabels } from '@/lib/labels';
+
+export const LabelContext = createContext(englishLabels);
+export function useLabels() {
+  return useContext(LabelContext);
+}

package/src/lib/labels.ts

@@ -0,0 +1,37 @@
+import { resolveLocale } from '@/lib/locale';
+import de from '@/lib/translations/de.json';
+import en from '@/lib/translations/en.json';
+import es from '@/lib/translations/es.json';
+import fr from '@/lib/translations/fr.json';
+import ja from '@/lib/translations/ja.json';
+import zhHans from '@/lib/translations/zh-Hans.json';
+import zhHant from '@/lib/translations/zh-Hant.json';
+import type { ThemeLabels, Translations } from '@/lib/types';
+
+export const englishLabels: ThemeLabels = en;
+const dictionaries: Record<string, ThemeLabels> = {
+  en,
+  de,
+  es,
+  fr,
+  ja,
+  'zh-Hans': zhHans,
+  'zh-Hant': zhHant,
+};
+
+/** Merge from least to most specific; overrides win at each locale level. */
+export function resolveLabels(locale: string, overrides: Translations = {}): ThemeLabels {
+  const tag = new Intl.Locale(resolveLocale(locale, 'en'));
+  const script = tag.script || (tag.language === 'zh' ? tag.maximize().script : undefined);
+  const candidates = new Set([
+    'en',
+    tag.language,
+    ...(script ? [`${tag.language}-${script}`] : []),
+    tag.baseName,
+  ]);
+  const labels = { ...englishLabels };
+  for (const candidate of candidates) {
+    Object.assign(labels, dictionaries[candidate], overrides[candidate]);
+  }
+  return labels;
+}

package/src/lib/openapi.generated.ts

@@ -1,4 +1,5 @@
 // Build-time alias target. Shiso replaces this module with the project's generated operations.
-import type { NormalizedOperation } from '@/lib/types';
+import type { NormalizedOperation, SchemaPage } from '@/lib/types';
 
 export const OPENAPI_OPERATIONS: Record<string, NormalizedOperation> = {};
+export const OPENAPI_SCHEMAS: Record<string, SchemaPage> = {};

package/src/lib/openapi.ts

@@ -1,3 +1,4 @@
+import { englishLabels } from '@/lib/labels';
 /**
  * Runtime helpers for OpenAPI reference pages. Operation data is produced at
  * build time by scripts/generate-openapi.mjs and reaches the client through
@@ -5,9 +6,18 @@
  */
 
 import type { BadgeColor } from '@/components/docs/Badge';
-import { OPENAPI_OPERATIONS } from '@/lib/openapi.generated';
+import { OPENAPI_OPERATIONS, OPENAPI_SCHEMAS } from '@/lib/openapi.generated';
 import { createSlugger } from '@/lib/slug';
-import type { NormalizedOperation, TocEntry } from '@/lib/types';
+import type {
+  ApiPlaygroundDisplay,
+  DocFrontmatter,
+  NormalizedOperation,
+  ResolvedApiPlayground,
+  SchemaPage,
+  SecurityScheme,
+  ThemeLabels,
+  TocEntry,
+} from '@/lib/types';
 
 export const METHOD_COLORS: Record<string, BadgeColor> = {
   GET: 'green',
@@ -15,8 +25,33 @@ export const METHOD_COLORS: Record<string, BadgeColor> = {
   PUT: 'orange',
   PATCH: 'purple',
   DELETE: 'red',
+  WEBHOOK: 'yellow',
 };
 
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE']);
+
+/** Short sidebar badge text for a method. */
+export function methodBadgeText(method: string): string {
+  if (method === 'DELETE') return 'DEL';
+  if (method === 'WEBHOOK') return 'HOOK';
+  return method;
+}
+
+/**
+ * Normalizes an `openapi:` frontmatter value into a lookup key. Mirrors
+ * normalizeOperationKey in scripts/lib/openapi.mjs: the method (or "webhook")
+ * is uppercased and an optional leading spec qualifier is kept verbatim.
+ */
+export function normalizeOperationKey(value: unknown): string | undefined {
+  if (typeof value !== 'string' || !value.trim()) return undefined;
+  const [first, ...rest] = value.trim().split(/\s+/);
+  if (!rest.length) return undefined;
+  const upper = first.toUpperCase();
+  if (upper === 'WEBHOOK' || HTTP_METHODS.has(upper)) return `${upper} ${rest.join(' ')}`;
+  const inner = normalizeOperationKey(rest.join(' '));
+  return inner ? `${first} ${inner}` : undefined;
+}
+
 export function methodColor(method?: string): BadgeColor {
   return (method && METHOD_COLORS[method.toUpperCase()]) || 'gray';
 }
@@ -28,14 +63,68 @@ export function statusColor(status: string): BadgeColor {
   return 'gray';
 }
 
+/** Options that change which generated sections an operation page renders. */
+export interface OperationSectionOptions {
+  /** Whether the "Try it" panel renders ahead of the reference sections. */
+  playground?: boolean;
+}
+
+/**
+ * Resolves the effective playground display for a page: the frontmatter
+ * `playground` value wins over `api.playground.display`.
+ */
+export function resolvePlaygroundDisplay(
+  playground: ResolvedApiPlayground,
+  frontmatter?: DocFrontmatter,
+): ApiPlaygroundDisplay {
+  const override = frontmatter?.playground;
+  if (override === 'interactive' || override === 'simple' || override === 'none') {
+    return override;
+  }
+  return playground.display;
+}
+
 /** Looks up the operation bound by an `openapi:` frontmatter value. */
 export function getOperation(key?: unknown): NormalizedOperation | undefined {
-  if (typeof key !== 'string' || !key.trim()) {
-    return undefined;
-  }
+  const normalized = normalizeOperationKey(key);
+  return normalized ? OPENAPI_OPERATIONS[normalized] : undefined;
+}
+
+/** Looks up the schema bound by an `openapi-schema:` frontmatter value. */
+export function getSchema(key?: unknown): SchemaPage | undefined {
+  if (typeof key !== 'string' || !key.trim()) return undefined;
+  return OPENAPI_SCHEMAS[key.trim().split(/\s+/).join(' ')];
+}
+
+/**
+ * Section headings for a schema page, in render order. Mirrors schemaAnchors
+ * in scripts/lib/openapi.mjs.
+ */
+export function schemaSections(page: SchemaPage, labels: ThemeLabels = englishLabels): TocEntry[] {
+  return [
+    ...(page.schema.children?.length
+      ? [{ name: labels.apiSchemaProperties, id: 'properties', size: 2 }]
+      : []),
+    ...(page.example ? [{ name: labels.apiExample, id: 'example', size: 2 }] : []),
+  ];
+}
+
+/** Where a security scheme's credential travels: a header unless it is a query or cookie API key. */
+export function securityLocation(scheme: SecurityScheme): 'header' | 'query' | 'cookie' {
+  return scheme.type === 'apiKey' && scheme.in ? scheme.in : 'header';
+}
+
+/** Security schemes that are sent in the given parameter location. */
+export function securityForLocation(
+  operation: NormalizedOperation,
+  location: 'header' | 'path' | 'query' | 'cookie',
+): SecurityScheme[] {
+  return operation.security.filter(scheme => securityLocation(scheme) === location);
+}
 
-  const [method, ...rest] = key.trim().split(/\s+/);
-  return OPENAPI_OPERATIONS[`${method.toUpperCase()} ${rest.join(' ')}`];
+/** Display name of the header, query, or cookie entry a scheme adds. */
+export function securityFieldName(scheme: SecurityScheme): string {
+  return scheme.type === 'apiKey' ? scheme.paramName || scheme.name : 'Authorization';
 }
 
 export function hasParameters(operation: NormalizedOperation): boolean {
@@ -46,18 +135,21 @@ export function hasParameters(operation: NormalizedOperation): boolean {
 }
 
 /** Parameter groups shared by the renderer and table of contents. */
-export function operationParameterSections(operation: NormalizedOperation) {
+export function operationParameterSections(
+  operation: NormalizedOperation,
+  labels: ThemeLabels = englishLabels,
+) {
   const groups = [
-    { location: 'header', name: 'Headers' },
-    { location: 'path', name: 'Path parameters' },
-    { location: 'query', name: 'Query parameters' },
-    { location: 'cookie', name: 'Cookie parameters' },
+    { location: 'header', name: labels.apiHeaders },
+    { location: 'path', name: labels.apiPathParameters },
+    { location: 'query', name: labels.apiQueryParameters },
+    { location: 'cookie', name: labels.apiCookieParameters },
   ] as const;
 
   return groups.filter(
     ({ location }) =>
       operation.parameters[location].length > 0 ||
-      (location === 'header' && operation.security.length > 0),
+      securityForLocation(operation, location).length > 0,
   );
 }
 
@@ -66,14 +158,29 @@ export function operationParameterSections(operation: NormalizedOperation) {
  * truth for section ids: the component, the table of contents, the content
  * checker, and the search indexer all derive their anchors from these labels.
  */
-export function operationSections(operation: NormalizedOperation): TocEntry[] {
+export function operationSections(
+  operation: NormalizedOperation,
+  labels: ThemeLabels = englishLabels,
+  options: OperationSectionOptions = {},
+): TocEntry[] {
   const slugger = createSlugger();
+  const playground = options.playground && !operation.webhook;
   const names = [
+    playground ? 'Try it' : undefined,
     ...operationParameterSections(operation).map(section => section.name),
-    operation.requestBody ? 'Request body' : undefined,
+    operation.requestBody ? (operation.webhook ? 'Payload' : 'Request body') : undefined,
     operation.responses.length ? 'Responses' : undefined,
     operation.samples.length ? 'Code samples' : undefined,
   ].filter((name): name is string => Boolean(name));
 
-  return names.map(name => ({ name, id: slugger.slug(name), size: 2 }));
+  const translated = [
+    ...(playground ? [labels.apiPlayground] : []),
+    ...operationParameterSections(operation, labels).map(section => section.name),
+    ...(operation.requestBody
+      ? [operation.webhook ? labels.apiPayload : labels.apiRequestBody]
+      : []),
+    ...(operation.responses.length ? [labels.apiResponses] : []),
+    ...(operation.samples.length ? [labels.apiCodeSamples] : []),
+  ];
+  return names.map((name, index) => ({ name: translated[index], id: slugger.slug(name), size: 2 }));
 }

package/src/lib/site-config.ts

@@ -8,6 +8,7 @@ import {
   getPageByPathname as getSitePageByPathname,
   normalizeDocsSite,
 } from '@/lib/docs-config';
+import { resolveLabels } from '@/lib/labels';
 import { getTextDirection, resolveLocale } from '@/lib/locale';
 import { DOCS_PREFIX, stripBase } from '@/lib/paths';
 import { resolveSiteModel } from '@/lib/site-model';
@@ -53,10 +54,60 @@ export function getStandalonePage(pathname: string): StandalonePage | null {
   return getStandalonePageByPathname(standalonePages, stripBase(pathname));
 }
 
-/** Scope that owns the current pathname; the default scope for unknown paths. */
+/** Landing scope of a language: its default version. */
+function getLanguageScope(language: string): DocsScope | undefined {
+  return docsSite.scopes.find(scope => scope.language === language && scope.isLanguageDefault);
+}
+
+/**
+ * Scope that owns the current pathname. A standalone page tagged with a
+ * `language` belongs to that language's landing scope; unknown paths and
+ * untagged standalone pages belong to the default scope.
+ */
 export function getScopeByPathname(pathname: string): DocsScope {
   const page = getPageByPathname(pathname);
-  return page ? getScopeForPage(docsSite, page) : getDefaultScope(docsSite);
+
+  if (page) {
+    return getScopeForPage(docsSite, page);
+  }
+
+  const standalone = getStandalonePage(pathname);
+  const languageScope = standalone?.language ? getLanguageScope(standalone.language) : undefined;
+
+  return languageScope || getDefaultScope(docsSite);
+}
+
+/**
+ * The same standalone page in another language, matched by `key`. Untagged
+ * pages count as the default scope's language.
+ */
+export function getStandaloneCounterpart(
+  page: StandalonePage,
+  language: string,
+): StandalonePage | null {
+  const defaultLanguage = getDefaultScope(docsSite).language;
+
+  return (
+    standalonePages.find(
+      candidate =>
+        candidate.key === page.key && (candidate.language || defaultLanguage) === language,
+    ) || null
+  );
+}
+
+/**
+ * Home link for the current pathname: the "/" standalone page in the current
+ * language when one exists, else "/", else the docs home when nothing owns "/".
+ */
+export function getHomeHref(pathname: string): string {
+  const root = standalonePages.find(page => page.path === '/');
+
+  if (!root) {
+    return docsHomeUrl;
+  }
+
+  const language = getScopeByPathname(pathname).language;
+  return (language && getStandaloneCounterpart(root, language)?.path) || '/';
 }
 
 /** Document language and direction for a pathname, from its scope's language. */
@@ -65,6 +116,19 @@ export function getLocaleByPathname(pathname: string): { lang: string; dir: 'ltr
   return { lang, dir: getTextDirection(lang) };
 }
 
+/** Resolve UI text on every route, including standalone pages and language switches. */
+export function getSiteModelByPathname(pathname: string) {
+  const { lang } = getLocaleByPathname(pathname);
+  const labels = resolveLabels(lang, shisoConfig.translations);
+  const customPrompt =
+    typeof siteConfig.search === 'object' ? siteConfig.search.prompt?.trim() : undefined;
+  return {
+    ...siteModel,
+    labels,
+    search: { ...siteModel.search, prompt: customPrompt || labels.searchPlaceholder },
+  };
+}
+
 export const siteName = siteModel.name;
 
 /** Trailing-slash-insensitive route key for redirect matching. */

package/src/lib/site-model.ts

@@ -1,4 +1,5 @@
 import { resolveCodeBlockConfig } from '@/lib/code-blocks';
+import { resolveLabels, englishLabels as SHISO_THEME_LABELS } from '@/lib/labels';
 import { toAbsoluteUrl, toHref } from '@/lib/paths';
 import { resolveSearchConfig } from '@/lib/search/config';
 import type {
@@ -18,37 +19,6 @@ import type {
   ThemeLabels,
 } from '@/lib/types';
 
-const SHISO_THEME_LABELS: ThemeLabels = {
-  menu: 'Menu',
-  documentationNavigation: 'Documentation navigation',
-  sections: 'Sections',
-  tableOfContents: 'On this page',
-  tableOfContentsNavigation: 'Table of contents',
-  searchTitle: 'Search',
-  searching: 'Searching...',
-  searchUnavailable: 'Search unavailable',
-  noResults: 'No results',
-  lastUpdated: 'Last updated on',
-  relatedTopics: 'Related topics',
-  previousPage: 'Previous',
-  nextPage: 'Next',
-  notFound: 'Page not found',
-  dismissBanner: 'Dismiss banner',
-  toggleTheme: 'Toggle theme',
-  moreOptions: 'More options',
-  copied: 'Copied',
-  expand: 'Expand',
-  collapse: 'Collapse',
-  copyPage: 'Copy page',
-  copyPageDescription: 'Copy this page as Markdown',
-  viewMarkdown: 'View as Markdown',
-  viewMarkdownDescription: 'Open this page as plain Markdown',
-  openInChatGPT: 'Open in ChatGPT',
-  openInClaude: 'Open in Claude',
-  openInPerplexity: 'Open in Perplexity',
-  askQuestionsAboutPage: 'Ask questions about this page',
-};
-
 function isInternalHref(href: string): boolean {
   return /^(?:#|\/|\.\.?\/)/.test(href);
 }
@@ -78,6 +48,17 @@ function normalizeNavbar(config: DocsConfig['navbar']): NormalizedNavbar | null
   return links.length || primary ? { links, primary } : null;
 }
 
+function normalizePlayground(config: DocsConfig['api']): SiteModel['api']['playground'] {
+  const playground = config?.playground;
+  const display =
+    playground?.display === 'simple' || playground?.display === 'none'
+      ? playground.display
+      : 'interactive';
+  const proxy = playground?.proxy?.trim() || undefined;
+
+  return proxy ? { display, proxy } : { display };
+}
+
 function normalizeFooter(config: DocsConfig['footer']): NormalizedFooter | null {
   const socials = (config?.socials || []).filter(link => !!link?.href).map(normalizeLink);
   const links = (config?.links || [])
@@ -141,7 +122,8 @@ export function resolveSiteModel(
     showTimestamp: config.metadata?.timestamp === true,
     drilldown: config.interaction?.drilldown,
     locale: shiso?.locale || 'en-US',
-    labels: SHISO_THEME_LABELS,
+    labels: resolveLabels(shiso?.locale || 'en-US', shiso?.translations),
+    api: { playground: normalizePlayground(config.api) },
     docs,
   };
 }

package/src/lib/standalone-pages.ts

@@ -108,7 +108,21 @@ export function normalizeStandalonePages(
       );
     }
 
-    pages.push({ path, filePath, title: item?.title?.trim() || undefined });
+    const language = item?.language?.trim() || undefined;
+
+    if (language && !site.scopes.some(scope => scope.language === language)) {
+      throw invalid(
+        `standalone page "${path}" uses language "${language}", which is not declared in navigation.languages.`,
+      );
+    }
+
+    // Language-independent identity: "ja/home" in language "ja" is the "home" page.
+    const key =
+      language && fileSlug.startsWith(`${language}/`)
+        ? fileSlug.slice(language.length + 1)
+        : fileSlug;
+
+    pages.push({ path, filePath, title: item?.title?.trim() || undefined, language, key });
   }
 
   return pages;

package/src/lib/translations/de.json

@@ -0,0 +1,99 @@
+{
+  "menu": "Menü",
+  "documentationNavigation": "Dokumentationsnavigation",
+  "sections": "Abschnitte",
+  "tableOfContents": "Auf dieser Seite",
+  "tableOfContentsNavigation": "Inhaltsverzeichnis",
+  "searchTitle": "Suchen",
+  "searching": "Suche läuft...",
+  "searchUnavailable": "Suche nicht verfügbar",
+  "noResults": "Keine Ergebnisse",
+  "lastUpdated": "Zuletzt aktualisiert am",
+  "relatedTopics": "Verwandte Themen",
+  "previousPage": "Zurück",
+  "nextPage": "Weiter",
+  "notFound": "Seite nicht gefunden",
+  "dismissBanner": "Banner schließen",
+  "toggleTheme": "Design wechseln",
+  "moreOptions": "Weitere Optionen",
+  "copied": "Kopiert",
+  "expand": "Aufklappen",
+  "collapse": "Zuklappen",
+  "copyPage": "Seite kopieren",
+  "copyPageDescription": "Diese Seite als Markdown kopieren",
+  "viewMarkdown": "Als Markdown anzeigen",
+  "viewMarkdownDescription": "Diese Seite als reinen Markdown-Text öffnen",
+  "openInChatGPT": "In ChatGPT öffnen",
+  "openInClaude": "In Claude öffnen",
+  "openInPerplexity": "In Perplexity öffnen",
+  "askQuestionsAboutPage": "Fragen zu dieser Seite stellen",
+  "searchPlaceholder": "Suchen...",
+  "poweredBy": "Erstellt mit",
+  "copyCode": "Code kopieren",
+  "editPage": "Diese Seite bearbeiten",
+  "feedbackPrompt": "War diese Seite hilfreich?",
+  "feedbackYes": "Ja",
+  "feedbackNo": "Nein",
+  "feedbackSuccess": "Vielen Dank für dein Feedback!",
+  "feedbackError": "Feedback konnte nicht gesendet werden. Bitte versuche es erneut.",
+  "close": "Schließen",
+  "filterUpdates": "Aktualisierungen nach Tag filtern",
+  "clear": "Zurücksetzen",
+  "noUpdates": "Keine Aktualisierungen gefunden.",
+  "codeSnippets": "Codebeispiele",
+  "contentTabs": "Inhaltsregisterkarten",
+  "fileTree": "Dateibaum",
+  "diagram": "Diagramm",
+  "diagramError": "Dieses Diagramm konnte nicht angezeigt werden.",
+  "zoomOut": "Verkleinern",
+  "resetView": "Ansicht zurücksetzen",
+  "zoomIn": "Vergrößern",
+  "viewImage": "Bild in voller Größe anzeigen",
+  "viewNamedImage": "„{alt}“ in voller Größe anzeigen",
+  "fullSizeImage": "Bild in voller Größe",
+  "diagramSource": "Diagrammquelltext",
+  "fieldName": "Name",
+  "fieldType": "Typ",
+  "fieldDescription": "Beschreibung",
+  "fieldRequired": "erforderlich",
+  "fieldDeprecated": "veraltet",
+  "fieldDefault": "Standard:",
+  "fieldOptions": "Optionen:",
+  "allowedTypes": "Zulässige Typen",
+  "properties": "Eigenschaften",
+  "apiHeaders": "Header",
+  "apiPathParameters": "Pfadparameter",
+  "apiQueryParameters": "Abfrageparameter",
+  "apiCookieParameters": "Cookie-Parameter",
+  "apiRequestBody": "Anfragetext",
+  "apiResponses": "Antworten",
+  "apiCodeSamples": "Codebeispiele",
+  "apiExampleRequest": "Beispielanfrage",
+  "apiExampleResponse": "Beispiel für {status}",
+  "apiCredentials": "Anmeldedaten, z. B.",
+  "apiPlayground": "Ausprobieren",
+  "apiServer": "Server",
+  "apiAuthorization": "Autorisierung",
+  "apiUsername": "Benutzername",
+  "apiPassword": "Passwort",
+  "apiToken": "Token",
+  "apiApiKey": "API-Schlüssel",
+  "apiBody": "Body",
+  "apiSend": "Anfrage senden",
+  "apiSending": "Wird gesendet...",
+  "apiCancel": "Abbrechen",
+  "apiRequest": "Anfrage",
+  "apiResponse": "Antwort",
+  "apiResponseHeaders": "Antwort-Header",
+  "apiResponseBody": "Antwort-Body",
+  "apiNoResponse": "Senden Sie eine Anfrage, um die Antwort zu sehen.",
+  "apiRequestFailed": "Die Anfrage konnte nicht gesendet werden. Die API blockiert möglicherweise Browser-Anfragen (CORS) oder ist nicht erreichbar; konfigurieren Sie einen Playground-Proxy oder führen Sie das cURL-Beispiel im Terminal aus.",
+  "apiRequestTimedOut": "Zeitüberschreitung der Anfrage.",
+  "apiCookiesUnsupported": "Cookie-Parameter können im Browser nicht gesetzt werden und werden nicht gesendet.",
+  "apiOptional": "optional",
+  "apiElapsed": "{ms} ms",
+  "apiCredentialsStored": "Zugangsdaten bleiben in diesem Browser-Tab und werden nur an die API gesendet.",
+  "apiPayload": "Nutzdaten",
+  "apiSchemaProperties": "Eigenschaften",
+  "apiExample": "Beispiel"
+}