AfiS-Aktensystem/web/lib/i18n/de.ts

/**
 * Alle Oberflaechentexte. Nie deutsche Strings hart ins JSX, siehe CLAUDE.md.
 * Die Begriffe folgen dem Glossar in docs/01-produkt.md.
 *
 * Schreibweise nach docs/10-design-system.md:
 *  - Aktive Verben, die sagen, was passiert: "Vermerk speichern", nicht "Absenden"
 *  - Dieselbe Bezeichnung durch den ganzen Ablauf
 *  - Fehler nennen Ursache und naechsten Schritt, ohne Entschuldigung
 *  - Leere Zustaende sind eine Aufforderung
 *  - Keine Ausrufezeichen, kein "bitte", kein "erfolgreich"
 */
export const de = {
  app: {
    name: 'AfiS-Aktensystem',
    shortName: 'AfiS',
    description: 'Fallakten, Personalakten und Ermittlungen der Abteilung für innere Sicherheit',
  },

  nav: {
    dashboard: 'Übersicht',
    cases: 'Fallakten',
    personnel: 'Personalakten',
    search: 'Suche',
    admin: 'Verwaltung',
    skipToContent: 'Zum Inhalt springen',
  },

  auth: {
    signIn: 'Mit Discord anmelden',
    signOut: 'Abmelden',
    signedInAs: 'Angemeldet als',
    intro:
      'Die Anmeldung läuft über Discord. Zugriff haben Mitglieder der Abteilung für innere Sicherheit.',
    reasons: {
      'keine-mitgliedschaft': {
        title: 'Du bist nicht auf dem AfiS-Discord',
        body: 'Die Anmeldung setzt eine Mitgliedschaft auf dem Discord-Server voraus. Wende dich an die Abteilungsleitung.',
      },
      'keine-afis-rolle': {
        title: 'Keine Berechtigung für das Aktensystem',
        body: 'Du bist auf dem Server, trägst aber keine Rolle der Abteilung. Wende dich an die Abteilungsleitung.',
      },
      'discord-nicht-erreichbar': {
        title: 'Discord antwortet nicht',
        body: 'Die Mitgliedschaft war nicht prüfbar. In einigen Minuten erneut versuchen.',
      },
    } as Record<string, { title: string; body: string }>,
    sessionEnded: {
      title: 'Sitzung beendet',
      body: 'Deine Rollen haben sich geändert. Melde dich neu an.',
    },
    error: {
      title: 'Anmeldung nicht möglich',
      body: 'Der Anmeldevorgang wurde abgebrochen. Erneut versuchen.',
    },
    backToSignIn: 'Zurück zur Anmeldung',
  },

  overview: {
    heading: 'Dein Zugang',
    intro: 'Was das System über dich weiss und was daraus folgt.',
    person: 'Person',
    discordId: 'Discord-Kennung',
    roles: 'Rollen auf dem Discord',
    clearance: 'Errechnete Freigabestufe',
    permissions: 'Rechte',
    noPermissions: 'Keine Rechte. Die Abteilungsleitung vergibt sie in der Rollenverwaltung.',
    noRoles: 'Keine Rollen.',
    bootstrapAdmin: 'Notfallzugang aus der Konfiguration, unabhängig vom Rollen-Mapping',
    unmapped: 'nicht zugeordnet',
  },

  roleAdmin: {
    heading: 'Rollenverwaltung',
    intro:
      'Jede Rolle des Discord-Servers steht hier. Zugangsrollen bestimmen die Freigabestufe, Rangrollen die Rechte, und eine Zugehörigkeitsrolle entscheidet, wer sich überhaupt anmelden darf.',
    empty:
      'Noch keine Rollen eingelesen. Der Worker spiegelt sie, sobald er am Discord-Gateway hängt.',
    role: 'Rolle',
    category: 'Sorte',
    clearance: 'Freigabestufe',
    grantsMembership: 'Darf sich anmelden',
    permissions: 'Rechte',
    missingFromGuild: 'Auf dem Server nicht mehr vorhanden',
    save: 'Zuordnung speichern',
    invalidInput: 'Eingabe nicht gültig',
    roleGone: 'Rolle nicht gefunden, sie wurde zwischenzeitlich gelöscht',
    saving: 'Wird gespeichert',
    saved: 'Zuordnung gespeichert',
    confirm: 'Rollen-Mapping ändern? Das wirkt sofort für alle angemeldeten Personen.',
    categories: {
      MEMBERSHIP: 'Zugehörigkeit',
      RANK: 'Rang',
      CLEARANCE: 'Zugang',
      UNSORTED: 'Nicht eingeordnet',
    } as Record<string, string>,
    optIn:
      'Dieses Recht ist im Auslieferungszustand keiner Rolle zugeordnet. Vergib es bewusst.',
    preview: {
      heading: 'Vorschau',
      intro: 'Was jemand mit dieser Stufe sieht, wenn er keine weiteren Rollen hat.',
      level: 'Stufe',
      sees: 'Sieht Akten bis einschliesslich',
      hidden: 'Höhere Akten sind unsichtbar',
      lockedOnly: 'Höhere Akten sind sichtbar, aber gesperrt',
      nobody: 'Keine Rolle führt zu dieser Stufe',
      viaRoles: 'Erreichbar über',
    },
  },

  clearance: {
    label: 'Freigabestufe',
    classification: 'Klassifizierung',
    level: (n: number) => `Stufe ${n}`,
    // Die Bezeichnungen der Stufen stehen nicht hier, sondern in
    // ClearanceLevelConfig: sie sind im Adminbereich änderbar und folgen den
    // Zugangsrollen des Discord-Servers. Siehe docs/13-entscheidungen.md.
    locked: 'Inhalt gesperrt',
    lockedHint: (n: number) => `Sichtbar ab Stufe ${n}`,
    redacted: 'Geschwärzt',
    redactedHint: (n: number) => `Geschwärzt, ab Stufe ${n} sichtbar`,
  },

  case: {
    one: 'Fallakte',
    many: 'Fallakten',
    number: 'Aktenzeichen',
    title: 'Titel',
    type: 'Fallart',
    status: 'Status',
    dueAt: 'Wiedervorlage',
    outcome: 'Ergebnis',
    createdBy: 'Angelegt von',
    timeline: 'Verlauf',
    sections: 'Abschnitte',
    chat: 'Aktenchat',
    changes: 'Änderungen',
    participants: 'Beteiligte',
    links: 'Verknüpfungen',
    attachments: 'Anhänge',
    empty: 'Noch keine Fallakte. Erste Fallakte anlegen.',
    create: 'Fallakte anlegen',
    createTitle: 'Neue Fallakte',
    subject: 'Betroffene Person',
    subjectNone: 'Keine',
    open: 'Öffnen',
    updatedAt: 'Zuletzt geändert',
    more: 'Weitere laden',
    listHeading: 'Fallakten',
    countLabel: (n: number) => (n === 1 ? '1 Akte' : `${n} Akten`),
    filterStatus: 'Status',
    filterAll: 'Alle',
    reclassify: 'Klassifizierung ändern',
    reclassifyReason: 'Begründung der Herabstufung',
    statusChange: 'Status ändern',
    newEntry: 'Neuer Vermerk',
    entryPlaceholder: 'Was ist passiert?',
    saving: 'Wird gespeichert',
    unsaved: 'Nicht gespeichert',
    statusNames: {
      DRAFT: 'Entwurf',
      OPEN: 'Offen',
      DORMANT: 'Ruhend',
      REVIEW: 'In Prüfung',
      CLOSED: 'Abgeschlossen',
      ARCHIVED: 'Archiviert',
      SEALED: 'Versiegelt',
    } as Record<string, string>,
  },

  section: {
    heading: 'Abschnitte',
    empty: 'Die Vorlage dieser Fallart hat keine Abschnitte.',
    save: 'Abschnitt speichern',
    saving: 'Wird gespeichert',
    saved: 'Gespeichert',
    draftKept: 'Entwurf lokal gesichert',
    version: (v: number) => `v${v}`,
    history: 'Fassungen',
    conflict:
      'Nicht gespeichert, die Akte wurde zwischenzeitlich geändert. Fassungen vergleichen.',
    mine: 'Meine Fassung',
    theirs: 'Fremde Fassung',
    takeMine: 'Meine übernehmen',
    takeTheirs: 'Fremde übernehmen',
    redacted: 'Geschwärzt',
    redactedFrom: (n: number) => `Geschwärzt, ab Stufe ${n} sichtbar`,
    lockedField: (n: number) => `Feld gesperrt, sichtbar ab Stufe ${n}`,
    requiredToClose: 'Für den Abschluss nötig',
    signatureLine: 'Unterschrift',
  },

  entry: {
    one: 'Vermerk',
    many: 'Vermerke',
    create: 'Vermerk speichern',
    empty: 'Noch kein Vermerk. Ersten Vermerk anlegen.',
    edited: (v: number) => `bearbeitet · v${v}`,
    history: 'Änderungsverlauf',
    edit: 'Bearbeiten',
    editSave: 'Änderung speichern',
    retract: 'Zurückziehen',
    restore: 'Wiederherstellen',
    retractReason: 'Begründung der Zurücknahme',
    reasonTooShort: 'Begründung nötig, mindestens 10 Zeichen.',
    cancel: 'Abbrechen',
    changesHeading: 'Änderungen an dieser Akte',
    changesIntro:
      'Jede nachträgliche Änderung am Verlauf, chronologisch. Sichtbar für alle, die die Akte lesen dürfen.',
    changesEmpty: 'Bisher wurde nichts nachträglich geändert.',
    versionLabel: (v: number) => `Fassung ${v}`,
    before: 'Vorher',
    after: 'Jetzt',
    changeReason: 'Begründung',
    retracted: (date: string, person: string, reason: string) =>
      `Eintrag zurückgezogen am ${date} durch ${person} · Begründung: ${reason}`,
    types: {
      NOTE: 'Vermerk',
      INTERROGATION: 'Befragung',
      EVIDENCE: 'Beweismittel',
      STATUS_CHANGE: 'Statuswechsel',
      CORRECTION: 'Korrektur',
      SYSTEM: 'System',
    } as Record<string, string>,
  },

  personnel: {
    one: 'Personalakte',
    many: 'Personalakten',
    listHeading: 'Personalakten',
    name: 'Name',
    rank: 'Dienstgrad',
    department: 'Abteilung',
    status: 'Status',
    statusHint: 'Mehrere möglich. „Gekündigt" und „Verhaftet" schließen einander nicht aus.',
    statusNone: 'Kein Status gesetzt',
    filterStatus: 'Status',
    filterAll: 'Alle',
    note: 'Anmerkung',
    noteHelp: 'Steht im Kopf der Akte, etwa "kein Discord-Konto, Aktenlage aus 2025".',
    linkedAccount: 'Discord-Konto',
    noAccount: 'Ohne Discord-Konto',
    empty: 'Noch keine Personalakte. Erste Personalakte anlegen.',
    emptySearch: 'Kein Treffer. Anderen Begriff versuchen.',
    create: 'Personalakte anlegen',
    createTitle: 'Neue Personalakte',
    createHint:
      'Meist für Externe ohne Discord-Konto: Sicherheitsdienst, Zeugen, Vertragspartner. Zusammen mit der Akte entsteht das Aktenblatt als erster Eintrag.',
    search: 'Name, Dienstgrad oder Abteilung',
    countLabel: (n: number) => (n === 1 ? '1 Personalakte' : `${n} Personalakten`),
    edit: 'Kopfdaten ändern',
    reclassify: 'Klassifizierung ändern',
    headData: 'Kopfdaten',
    backlinks: 'Fälle mit dieser Person',
    backlinksEmpty: 'Diese Person kommt in keinem Fall vor, den du sehen darfst.',
    backlinksCount: (n: number) => (n === 1 ? '1 Fall' : `${n} Fälle`),
    linkCase: 'Fall verknüpfen',
    linkCaseHint: 'Aktenzeichen eintragen und die Rolle wählen, in der die Person darin vorkommt.',
  },

  assignment: {
    heading: 'Zuständige der Abteilung',
    empty: 'Niemand zugeordnet.',
    add: 'Mitglied zuordnen',
    remove: 'Entfernen',
    hint:
      'Wer hier steht, liest die Personalakte unabhängig von seiner Freigabestufe.',
    roles: {
      HANDLER: 'Aktenführung',
      INVESTIGATOR: 'Ermittler',
      CONTACT: 'Ansprechpartner',
    } as Record<string, string>,
  },

  participant: {
    heading: 'Beteiligte',
    empty: 'Noch niemand eingetragen.',
    add: 'Beteiligte eintragen',
    remove: 'Entfernen',
    role: 'Rolle',
    person: 'Person',
    pickUser: 'Mitglied',
    pickPersonnel: 'Personalakte',
    hint:
      'Wer hier steht, liest die Akte unabhängig von seiner Freigabestufe. Das ist der Weg, jemanden ausnahmsweise hinzuzuziehen.',
    roles: {
      LEAD: 'Ermittlungsführung',
      INVESTIGATOR: 'Ermittler',
      WITNESS: 'Zeuge',
      SUBJECT: 'Betroffener',
      OBSERVER: 'Beobachter',
    } as Record<string, string>,
  },

  link: {
    heading: 'Verknüpfungen',
    empty: 'Keine Verknüpfung.',
    add: 'Akte verknüpfen',
    remove: 'Verknüpfung lösen',
    target: 'Aktenzeichen',
    kind: 'Art',
    kinds: {
      RELATED: 'Verwandt',
      SUCCESSOR: 'Nachfolger',
      MERGED_INTO: 'Zusammengeführt in',
    } as Record<string, string>,
    incoming: {
      RELATED: 'Verwandt',
      SUCCESSOR: 'Vorgänger',
      MERGED_INTO: 'Zusammengeführt aus',
    } as Record<string, string>,
  },

  document: {
    one: 'Dokument',
    many: 'Dokumente',
    number: 'Dokumentnummer',
    title: 'Titel',
    kind: 'Dokumentart',
    heading: 'Dokumente',
    empty: 'Noch kein Dokument.',
    create: 'Dokument anlegen',
    createTitle: 'Neues Dokument',
    createHint: 'Die Vorlage bestimmt Aufbau und Aussehen. Der Titel lässt sich später ändern.',
    open: 'Öffnen',
    finalize: 'Ausfertigen',
    finalizeHint: 'Danach sind Änderungen nur noch mit eigenem Recht möglich.',
    retract: 'Zurückziehen',
    retractReason: 'Begründung der Zurücknahme',
    reclassify: 'Klassifizierung ändern',
    retracted: (date: string, person: string, reason: string) =>
      `Dokument zurückgezogen am ${date} durch ${person} · Begründung: ${reason}`,
    finalized: (date: string, person: string) => `Ausgefertigt am ${date} durch ${person}`,
    sheet: 'Aktenblatt',
    edit: 'Bearbeiten',
    print: 'Drucken',
    issuedAt: 'Ausgestellt',
    signedOn: 'Datum',
    unclassified: 'Ohne Klassifikation',
    photoEmpty: 'Lichtbild 3×4 cm',
    photoLater: 'Lichtbilder kommen mit der Dateiprüfung.',
    footerNote: 'Dieses Dokument ist klassifiziert. Nur für autorisiertes Personal.',
    ownerCase: 'Zur Fallakte',
    ownerPersonnel: 'Zur Personalakte',
    ownerNone: 'Ohne Besitzer',
    statusNames: {
      DRAFT: 'Entwurf',
      FINAL: 'Ausgefertigt',
      RETRACTED: 'Zurückgezogen',
    } as Record<string, string>,
    layoutNames: {
      FORM: 'Formular',
      PROSE: 'Vertragstext',
      NOTE: 'Vermerk',
      DOSSIER: 'Aktenblatt',
    } as Record<string, string>,
  },

  common: {
    save: 'Speichern',
    cancel: 'Abbrechen',
    undo: 'Rückgängig',
    retry: 'Erneut versuchen',
    loading: 'Wird geladen',
    offline: 'Keine Verbindung, wird nachgesendet',
    unknown: 'Unbekannt',
  },

  /**
   * Meldungen zu abgelehnten Aktionen. Der Schlüssel ist der `code` eines
   * `AccessError`, siehe lib/errors.ts. Gilt für Fallakten, Personalakten und
   * Dokumente gleichermaßen — die Regeln sind dieselben.
   */
  actionErrors: {
    'not-found': 'Die Akte gibt es nicht, oder du darfst sie nicht sehen.',
    'clearance-too-low': 'Deine Freigabestufe reicht dafür nicht.',
    'no-permission': 'Dir fehlt das nötige Recht.',
    'read-only': 'Der Datensatz ist schreibgeschützt.',
    closed: 'Der Vorgang ist abgeschlossen. Änderungen brauchen ein eigenes Recht.',
    'reason-required': 'Begründung nötig, mindestens 10 Zeichen.',
    'transition-invalid': 'Dieser Statuswechsel ist nicht vorgesehen.',
    'sections-incomplete': 'Es fehlen Pflichtangaben für den Abschluss.',
    'template-missing': 'Dafür gibt es keine Vorlage.',
    'field-unknown': 'Dieses Feld gehört nicht zur Vorlage.',
    'name-required': 'Ein Name mit mindestens zwei Zeichen ist nötig.',
    'participant-target': 'Entweder ein Discord-Konto oder eine Personalakte, nicht beides.',
    'link-self': 'Eine Akte lässt sich nicht mit sich selbst verknüpfen.',
    default: 'Nicht gespeichert. Erneut versuchen.',
  } as Record<string, string>,

  errors: {
    notFound: {
      title: 'Nicht gefunden',
      body: 'Die Seite gibt es nicht, oder du darfst sie nicht sehen.',
    },
    unexpected: {
      title: 'Nicht geladen',
      body: 'Der Abruf ist fehlgeschlagen. Erneut versuchen.',
    },
    conflict: 'Nicht gespeichert, die Akte wurde zwischenzeitlich geändert. Fassungen vergleichen.',
  },

  templateAdmin: {
    heading: 'Vorlagen',
    intro:
      'Eine Vorlage bestimmt, aus welchen Bausteinen eine Fallart besteht. Speichern legt eine neue Version an; bestehende Akten behalten die Version, mit der sie angelegt wurden.',
    empty: 'Noch keine Vorlage.',
    version: (v: number) => `Version ${v}`,
    fieldsLabel: 'Bausteine als JSON',
    fieldsHelp:
      'Liste von Bausteinen. Eingabefelder: shorttext, longtext, select, multiselect, date, person, number, checklist, table. Feste Bausteine: heading, paragraph, signature, pagebreak.',
    numberPrefix: 'Präfix des Aktenzeichens',
    numberPadding: 'Stellen der laufenden Nummer',
    save: 'Als neue Version speichern',
    saved: (v: number) => `Gespeichert als Version ${v}`,
    preview: 'Vorschau',
    previewIntro: 'So sieht eine neue Akte mit dieser Vorlage aus.',
    invalid: 'Die Bausteine sind kein gültiges JSON.',
    fieldsInvalid: 'Die Bausteine sind nicht gültig.',
    inputField: 'Eingabe',
    staticBlock: 'Fester Baustein',
  },

  settings: {
    heading: 'Änderungsrichtlinie',
    intro:
      'Regelt, ob und wie lange Verlaufseinträge nachträglich geändert werden dürfen. Gilt für die ganze Abteilung.',
    policy: 'Richtlinie',
    graceMinutes: 'Karenzzeit in Minuten',
    markGrace: 'Auch Änderungen in der Karenzzeit sichtbar markieren',
    save: 'Richtlinie speichern',
    saved: 'Richtlinie gespeichert',
    confirm: 'Änderungsrichtlinie ändern? Das gilt sofort für alle Akten.',
    policies: {
      APPEND_ONLY: 'Keine Änderung möglich, nur Korrektureinträge',
      GRACE_WINDOW: 'Eigene Einträge in der Karenzzeit frei änderbar, danach nur mit Recht',
      OPEN: 'Jederzeit änderbar, sofern das Recht vorliegt',
    } as Record<string, string>,
  },

  health: {
    heading: 'Systemzustand',
    service: 'Dienst',
    state: 'Zustand',
    checkedAt: (when: string) => `Zustand der Dienste, abgefragt ${when}`,
    ok: 'Betriebsbereit',
    degraded: 'Eingeschränkt',
    down: 'Gestört',
    components: {
      database: 'Datenbank',
      discordGateway: 'Discord-Gateway',
      clamav: 'Virenprüfung',
    } as Record<string, string>,
  },
} as const

export type Messages = typeof de