@auditcore/ui-core 0.3.0

package/dist/risk/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Datentypen des REST-Vertrags `auditcore_risk.web` (docs/ui/risk-rest.md).
+ * Die Komponenten lesen nur diese Felder; unbekannte Felder werden ignoriert.
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type ProfileStatus = 'LEGACY_CHARACTERIZED' | 'CANDIDATE_HUMAN_DECISION_REQUIRED' | 'APPROVED';
+export type WhenMissingColumns = 'error' | 'skip' | 'all_false' | 'undetermined';
+export type Severity = 'INFO' | 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+export interface ProfileReference {
+    id: string;
+    version: string;
+    fingerprint: string;
+    status: ProfileStatus | string;
+}
+export interface RuleView {
+    code: string;
+    label: string;
+    kind: string;
+    scope: 'record' | 'dataset' | string;
+    severity: Severity | string | null;
+    interpretation: string;
+    note: string | null;
+    requires: string[];
+    when_missing_columns: WhenMissingColumns | string;
+    inputs: string[];
+    parameters: JsonObject;
+    origin: JsonObject;
+}
+export interface FieldUse {
+    code: string;
+    label: string;
+    role: string;
+    absent: string;
+    empty: string;
+}
+export interface FieldEntry {
+    name: string;
+    meaning: string | null;
+    meaning_source: string | null;
+    requirement: 'required' | 'value_required' | 'optional' | string;
+    required_by: string[];
+    value_required_by: string[];
+    uses: FieldUse[];
+}
+export interface ProfileDetail extends ProfileReference {
+    kind: string;
+    legal_status: string;
+    rule_count: number;
+    field_count: number;
+    source: JsonObject;
+    input_contract: string | null;
+    open_decisions: string[];
+    summary_format: string | null;
+    assessment: string | null;
+    rules: RuleView[];
+    fields: FieldEntry[];
+}
+export interface FlagHit {
+    code: string;
+    label: string;
+    reason: string;
+    interpretation: string;
+    note: string | null;
+    severity: Severity | string | null;
+    messages: Record<string, string> | null;
+    evidence: JsonObject;
+    origin: JsonObject;
+    inputs?: JsonObject;
+}
+export interface RecordView {
+    index: number;
+    key?: JsonValue;
+    /** Code → Treffer (`true`), kein Merkmal (`false`) oder unbestimmt (`null`). */
+    flags: Record<string, boolean | null>;
+    codes: string[];
+    undetermined: Record<string, string>;
+    values: JsonObject;
+    assessment: JsonObject | null;
+    hits: FlagHit[];
+    /** Code → gelesene Eingabefelder mit Werten (Treffer und unbestimmte Merkmale). */
+    inputs?: Record<string, JsonObject>;
+}
+export interface DatasetFinding {
+    code: string;
+    label: string;
+    triggered: boolean;
+    value: number | string | null;
+    reason: string;
+    evidence: JsonObject;
+}
+export interface Evaluation {
+    library: string;
+    profile: ProfileReference;
+    records: RecordView[];
+    dataset: DatasetFinding[];
+    /** Übersprungene Regeln: Code → Grund (z. B. „Spalten fehlen: …“). */
+    skipped: Record<string, string>;
+    summary: JsonObject[];
+    rules?: RuleView[];
+    columns?: string[];
+    missing_columns?: Record<string, string[]>;
+}

package/dist/runner/aktionen.d.ts

@@ -0,0 +1,16 @@
+import { Store } from '../store';
+import { RunnerController, RunnerData } from './controller';
+import { RunnerPort } from './types';
+type Run = <T>(kind: string, task: (port: RunnerPort) => Promise<T>) => Promise<T | null>;
+export interface RunnerKontext {
+    store: Store<RunnerData>;
+    run: Run;
+    applied: (version: number) => void;
+}
+type ProfilAktionen = Pick<RunnerController, 'setze' | 'eingabe' | 'verwerfen' | 'pruefen' | 'anwenden' | 'gespeichertUebernehmen' | 'entwurfTrotzdemAnwenden' | 'verschiebe' | 'prioritaet'>;
+type WerkzeugAktionen = Pick<RunnerController, 'werkzeug' | 'werkzeugZahl' | 'werkzeugeSpeichern'>;
+type KlassenAktionen = Pick<RunnerController, 'neueKlasseEingabe' | 'klasseHinzufuegen' | 'klassenNameEingabe' | 'klasseUmbenennen'>;
+export declare function profilAktionen(kontext: RunnerKontext): ProfilAktionen;
+export declare function werkzeugAktionen({ store, run }: RunnerKontext): WerkzeugAktionen;
+export declare function klassenAktionen({ store }: RunnerKontext): KlassenAktionen;
+export {};

package/dist/runner/controller.d.ts

@@ -0,0 +1,72 @@
+import { RequestState, Store } from '../store';
+import { MessageParams } from '../i18n';
+import { RunnerMessageKey } from './messages';
+import { RunnerFeldArt } from './eingabe';
+import { RunnerPfad, RunnerPrioritaet, RunnerUnterschied } from './profil';
+import { RunnerAnsicht, RunnerPort, RunnerProfil, RunnerProfilStand, RunnerPruefung, RunnerStatus, RunnerWerkzeugEinstellung, RunnerWerkzeuge, RunnerWerkzeugProfile } from './types';
+export interface RunnerCallbacks {
+    applied?: (version: number) => void;
+    failed?: (message: string) => void;
+}
+export interface RunnerKonfliktStand {
+    gespeichert: RunnerProfilStand;
+    meldung: string;
+    unterschiede: readonly RunnerUnterschied[];
+}
+/** Rückmeldung nach einer Aktion (übersetzt in der Ansicht). */
+export interface RunnerMeldung {
+    key: RunnerMessageKey;
+    params?: MessageParams;
+    ton: 'success' | 'warning';
+}
+/** Stand; `error` ist die Meldung der letzten abgelehnten Anfrage. */
+export interface RunnerData extends RequestState<string> {
+    ansicht: RunnerAnsicht;
+    status: RunnerStatus | null;
+    stand: RunnerProfilStand | null;
+    entwurf: RunnerProfil | null;
+    pruefung: RunnerPruefung | null;
+    konflikt: RunnerKonfliktStand | null;
+    werkzeuge: RunnerWerkzeuge | null;
+    werkzeugEntwurf: RunnerWerkzeugProfile | null;
+    meldung: RunnerMeldung | null;
+    /** Rohtext der Eingabefelder je Feld-ID, solange getippt wird (Zahlen, Listen). */
+    eingaben: Readonly<Record<string, string>>;
+    /** Entwürfe der Klassennamen beim Umbenennen (bisheriger Name → Eingabe). */
+    klassenNamen: Readonly<Record<string, string>>;
+    /** Eingabe „Neue Klasse“. */
+    neueKlasse: string;
+}
+export interface RunnerSource {
+    /** Fachlogik; hat Vorrang vor `api`. */
+    port: () => RunnerPort | null | undefined;
+    /** Basis-URL der JSON-API (z. B. `/api`), wenn kein Port übergeben wird. */
+    api?: () => string | null | undefined;
+    callbacks?: () => RunnerCallbacks;
+}
+export interface RunnerController {
+    store: Store<RunnerData>;
+    load: () => Promise<void>;
+    zeige: (ansicht: RunnerAnsicht) => void;
+    setze: (pfad: RunnerPfad, wert: unknown) => void;
+    /** Eingabe eines Formularfelds: Rohtext merken, umgesetzten Wert in den Entwurf. */
+    eingabe: (pfad: RunnerPfad, art: RunnerFeldArt, roh: string | boolean) => void;
+    verwerfen: () => void;
+    pruefen: () => Promise<void>;
+    anwenden: () => Promise<void>;
+    gespeichertUebernehmen: () => void;
+    entwurfTrotzdemAnwenden: () => Promise<void>;
+    verschiebe: (index: number, richtung: -1 | 1) => void;
+    prioritaet: (index: number, aenderung: Partial<Pick<RunnerPrioritaet, 'verdraengbar' | 'min'>>) => void;
+    werkzeug: (profil: string, werkzeug: string, aenderung: Partial<RunnerWerkzeugEinstellung>) => void;
+    /** Zahleneingabe (Zeitlimit, Priorität) eines Werkzeugs; ungültiger Rohtext bleibt nur sichtbar. */
+    werkzeugZahl: (profil: string, werkzeug: string, feld: 'zeitlimit_s' | 'prioritaet', roh: string) => void;
+    werkzeugeSpeichern: () => Promise<void>;
+    neueKlasseEingabe: (roh: string) => void;
+    klasseHinzufuegen: () => void;
+    klassenNameEingabe: (alt: string, roh: string) => void;
+    klasseUmbenennen: (alt: string) => void;
+}
+export declare const INITIAL_RUNNER: RunnerData;
+export declare const RUNNER_ANSICHTEN: readonly RunnerAnsicht[];
+export declare function createRunnerController(source: RunnerSource): RunnerController;

package/dist/runner/eingabe.d.ts

@@ -0,0 +1,5 @@
+export type RunnerFeldArt = 'zahl' | 'schalter' | 'auswahl' | 'text' | 'liste';
+/** Eingabe eines Feldes in den Profilwert umsetzen (Zahl, Liste, Schalter, Text). */
+export declare function runnerEingabe(feldArt: RunnerFeldArt, roh: string | boolean): unknown;
+/** Schlüssel des Rohtexts einer Werkzeug-Zahleneingabe. */
+export declare function runnerWerkzeugFeldId(profil: string, werkzeug: string, feld: string): string;

package/dist/runner/index.d.ts

@@ -0,0 +1,9 @@
+export { runnerMessages, type RunnerMessageKey } from './messages';
+export type * from './types';
+export { createRunnerMemoryPort, createRunnerRestPort, RUNNER_SCHREIB_KOPF, RUNNER_WERKZEUG_SCHEMA } from './port';
+export * from './profil';
+export * from './controller';
+export type { RunnerKontext } from './aktionen';
+export * from './eingabe';
+export * from './view';
+export * from './view-listen';

package/dist/runner/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte der Runner-Konsole (Vue `RunnerConsole`, React `FlowauditRunnerConsole`); sichtbare Texte nur hier. */
+export declare const runnerMessages: import('..').Catalogs<"loading" | "meta" | "title" | "image" | "unbekannt" | "working" | "failed" | "hoch" | "fehlt" | "tabs" | "tabStatus" | "tabEinstellungen" | "tabWerkzeuge" | "tabPrioritaeten" | "syncAus" | "syncZentral" | "nurLesen" | "refresh" | "ueberblick" | "ziel" | "sollQuelle" | "profilVersion" | "aenderung" | "aenderungWert" | "aenderungKeine" | "netzsperre" | "kontingent" | "runnerVersion" | "runnerVersionFrist" | "vorhanden" | "aktiv" | "inaktiv" | "klassen" | "keineKlassen" | "spalteKlasse" | "spalteSoll" | "spalteMax" | "spalteInstanzen" | "spalteRegistriert" | "spalteBelegt" | "spalteWarteschlange" | "spalteGruende" | "hardware" | "hinweisUnbekannt" | "hinweisImage" | "hinweisNetzsperre" | "abschnittAllgemein" | "abschnittRegelung" | "abschnittThermik" | "abschnittNetz" | "abschnittKlasse" | "abschnittKarte" | "fSollQuelle" | "fSollDatei" | "fBackend" | "fImage" | "fReserveCpus" | "fReserveSpeicher" | "fVorrang" | "fLeerlauf" | "fAnteil" | "fSwap" | "fRam" | "fLast" | "fTemperatur" | "fVon" | "fBis" | "fHaltezeit" | "fThermikAktiv" | "fThermikUrl" | "fNetzAktiv" | "fSperre" | "kArt" | "oCpu" | "oGpu" | "klasseName" | "umbenennen" | "neueKlasse" | "hinzufuegen" | "klasseNameUngueltig" | "klasseNameVergeben" | "anmeldung" | "kAktiv" | "kMin" | "kMax" | "kLeise" | "kCpus" | "kSpeicher" | "kVram" | "kLabels" | "gErlaubt" | "gKlasse" | "oStatisch" | "oLokal" | "oDatei" | "pruefen" | "anwenden" | "verwerfen" | "ungespeichert" | "gueltig" | "ungueltig" | "probleme" | "vorschau" | "keineAenderung" | "schritte" | "rootBefehl" | "angewendet" | "nichtAngewendet" | "konflikt" | "konfliktFeld" | "konfliktEntwurf" | "konfliktGespeichert" | "gespeichertUebernehmen" | "entwurfAnwenden" | "werkzeugProfil" | "spalteWerkzeug" | "spalteBereich" | "spalteImage" | "spalteAktiv" | "spalteZeitlimit" | "spaltePrioritaet" | "nichtInstalliert" | "speichern" | "gespeichert" | "keineWerkzeuge" | "prioritaetenHinweis" | "keinePrioritaeten" | "rang" | "runter" | "verdraengbar" | "mindestens" | "weichtZuerst" | "keinerVerdraengbar">;
+export type RunnerMessageKey = keyof typeof runnerMessages.de;

package/dist/runner/port.d.ts

@@ -0,0 +1,20 @@
+import { RestOptions } from '@auditcore/common';
+import { RunnerPort, RunnerProfil, RunnerProfilStand, RunnerPruefung, RunnerStatus, RunnerWerkzeuge } from './types';
+/** Kopfzeile, ohne die `auditcore-runner ui` schreibende Anfragen ablehnt. */
+export declare const RUNNER_SCHREIB_KOPF: {
+    readonly 'X-Auditcore-Runner': "1";
+};
+export declare const RUNNER_WERKZEUG_SCHEMA = "auditcore-runner/werkzeuge/1";
+/** Port im Arbeitsspeicher (Demo, Tests); Konflikt, wenn `erwarteteVersion` nicht zur gespeicherten passt. */
+export declare function createRunnerMemoryPort(start: {
+    status: RunnerStatus;
+    profil: RunnerProfilStand;
+    werkzeuge?: RunnerWerkzeuge;
+    pruefen?: (profil: RunnerProfil) => RunnerPruefung;
+}): RunnerPort;
+/**
+ * Port auf die JSON-API von `auditcore-runner ui` (Basis z. B. `/api`).
+ * Schreibende Aufrufe senden `X-Auditcore-Runner: 1`; HTTP 409 beim Anwenden
+ * wird zum Ergebnis mit `konflikt: true`.
+ */
+export declare function createRunnerRestPort(rest: RestOptions): RunnerPort;

package/dist/runner/profil.d.ts

@@ -0,0 +1,39 @@
+import { RunnerProfil } from './types';
+export type RunnerPfad = readonly (string | number)[];
+export interface RunnerPrioritaet {
+    klasse: string;
+    rang: number;
+    verdraengbar: boolean;
+    min: number;
+}
+export interface RunnerUnterschied {
+    pfad: string;
+    entwurf: string;
+    gespeichert: string;
+}
+export declare function runnerWert(profil: RunnerProfil | null | undefined, pfad: RunnerPfad): unknown;
+/** Neuer Entwurf mit geändertem Wert; der alte bleibt unverändert. */
+export declare function runnerSetze(profil: RunnerProfil, pfad: RunnerPfad, wert: unknown): RunnerProfil;
+/** Feldweise Unterschiede (Pfad in Punktschreibweise), sortiert; ohne `version` und `aenderung`. */
+export declare function runnerUnterschiede(entwurf: RunnerProfil, gespeichert: RunnerProfil): RunnerUnterschied[];
+export declare function runnerGeaendert(entwurf: RunnerProfil | null, gespeichert: RunnerProfil | null): boolean;
+export declare function runnerVersion(profil: RunnerProfil | null | undefined): number;
+/** Prioritäten des Entwurfs nach Rang (1 = höchster), fehlerhafte Einträge übersprungen. */
+export declare function runnerPrioritaeten(profil: RunnerProfil | null | undefined): RunnerPrioritaet[];
+/** Eintrag an Position `index` um eine Stelle verschieben; Ränge werden fortlaufend neu vergeben. */
+export declare function runnerVerschiebe(profil: RunnerProfil, index: number, richtung: -1 | 1): RunnerProfil;
+/** Eigenschaft eines Prioritätseintrags (Position in der sortierten Liste) ändern. */
+export declare function runnerPrioritaetSetze(profil: RunnerProfil, index: number, aenderung: Partial<Pick<RunnerPrioritaet, 'verdraengbar' | 'min'>>): RunnerProfil;
+/** Wer bei knapper Kapazität zuerst weicht: der verdrängbare Eintrag mit dem niedrigsten Rang (größte Zahl). */
+export declare function runnerWeichtZuerst(liste: readonly RunnerPrioritaet[]): RunnerPrioritaet | null;
+/** Klassenname wie im Backend (`auditcore_runner.profile.CLASS_NAME`). */
+export declare const RUNNER_KLASSEN_NAME: RegExp;
+export type RunnerKlassenArt = 'cpu' | 'gpu';
+export declare function runnerKlassen(profil: RunnerProfil | null | undefined): string[];
+export declare function runnerKlassenArt(profil: RunnerProfil | null | undefined, name: string): RunnerKlassenArt;
+/** Fehlerart eines Klassennamens; `null` = gültig. `alt` ist der bisherige Name beim Umbenennen. */
+export declare function runnerKlassenNameFehler(profil: RunnerProfil | null | undefined, name: string, alt?: string): 'ungueltig' | 'vergeben' | null;
+/** Neue Klasse der Art `cpu` mit neutralen Werten (höchstens eine Instanz). */
+export declare function runnerKlasseHinzu(profil: RunnerProfil, name: string): RunnerProfil;
+/** Klasse umbenennen; Verweise in Karten, Prioritäten und das gleichnamige Label ziehen mit. */
+export declare function runnerKlasseUmbenennen(profil: RunnerProfil, alt: string, neu: string): RunnerProfil;

package/dist/runner/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Vertrag der lokalen JSON-API von `auditcore_runner` (`auditcore-runner ui`,
+ * Doku `packages/auditcore_runner/docs/api.md`). Feldnamen wie im Backend.
+ */
+export type RunnerAnsicht = 'status' | 'einstellungen' | 'werkzeuge' | 'prioritaeten';
+/** Stand einer Runner-Klasse im Status. `null`: unbekannt (z. B. GitHub nicht erreichbar). */
+export interface RunnerKlasseStatus {
+    aktiv: boolean;
+    max: number;
+    soll: number | null;
+    gruende: readonly string[];
+    instanzen_aktiv: number;
+    registriert: number | null;
+    belegt: number | null;
+    /** Wartende Jobs der Klasse (sobald das Backend sie liefert). */
+    warteschlange?: number | null;
+}
+export interface RunnerAenderung {
+    zeit: string;
+    quelle: string;
+    wer: string;
+}
+/** `GET /api/status` (Schema `auditcore-runner/status/1`). */
+export interface RunnerStatus {
+    rechner: string;
+    profil_version: number;
+    profil_hash: string;
+    aenderung: RunnerAenderung;
+    /** `aus` oder Name der zentralen Verwaltung. */
+    sync: string;
+    ziel: string;
+    soll_quelle: string;
+    /** Anmeldung bei GitHub: `gh`, `pat` oder `app` (optional). */
+    auth_art?: string;
+    hardware: Readonly<Record<string, unknown>>;
+    klassen: Readonly<Record<string, RunnerKlasseStatus>>;
+    image_vorhanden: boolean;
+    netz_vorhanden: boolean | null;
+    netzsperre_aktiv: boolean | null;
+    unbekannte_runner: readonly string[] | null;
+    github_rest_kontingent: number | null;
+    /** Runner-Version im Image und Frist, bis zu der sie aktualisiert sein muss (optional). */
+    runner_version?: string | null;
+    runner_frist?: string | null;
+    nur_lesen?: boolean;
+}
+/** Profil als JSON (Schema `auditcore-runner/profil/…`); unbekannte Felder bleiben erhalten. */
+export type RunnerProfil = Readonly<Record<string, unknown>>;
+export interface RunnerProblem {
+    feld: string;
+    meldung: string;
+}
+/** `GET /api/profil`. */
+export interface RunnerProfilStand {
+    profil: RunnerProfil;
+    profil_hash: string;
+    hardware: Readonly<Record<string, unknown>>;
+    probleme: readonly RunnerProblem[];
+    netzsperre_befehl: string | null;
+    nur_lesen?: boolean;
+}
+export interface RunnerDateiAenderung {
+    datei: string;
+    diff: string;
+}
+/** Ergebnis von `POST /api/profil/pruefen` bzw. `…/anwenden`. */
+export interface RunnerPruefung {
+    gueltig: boolean;
+    probleme: readonly RunnerProblem[];
+    aktive_version: number | null;
+    aenderungen: readonly RunnerDateiAenderung[];
+    schritte: readonly string[];
+    netzsperre_befehl: string | null;
+    angewendet?: boolean;
+    konflikt?: boolean;
+    meldung?: string;
+    version?: number;
+}
+export interface RunnerWerkzeug {
+    name: string;
+    bereich: string;
+    installation: string;
+    autofix: boolean;
+    kosten_minuten: number;
+    /** Installierte Version im Runner-Image, leer: nicht installiert. */
+    im_image: string;
+}
+export interface RunnerWerkzeugEinstellung {
+    aktiv: boolean;
+    zeitlimit_s: number;
+    prioritaet: number;
+}
+/** Prüfprofil → Werkzeug → Einstellung. */
+export type RunnerWerkzeugProfile = Readonly<Record<string, Readonly<Record<string, RunnerWerkzeugEinstellung>>>>;
+/** `GET /api/werkzeuge`. */
+export interface RunnerWerkzeuge {
+    werkzeuge: readonly RunnerWerkzeug[];
+    profile: RunnerWerkzeugProfile;
+}
+/** Fachlogik hinter der Oberfläche; Vue und React rufen nur diesen Port auf. */
+export interface RunnerPort {
+    status: () => Promise<RunnerStatus>;
+    profil: () => Promise<RunnerProfilStand>;
+    pruefen: (profil: RunnerProfil) => Promise<RunnerPruefung>;
+    /** Konflikt (HTTP 409) liefert `konflikt: true` statt eines Fehlers. */
+    anwenden: (profil: RunnerProfil, erwarteteVersion: number | null) => Promise<RunnerPruefung>;
+    werkzeuge: () => Promise<RunnerWerkzeuge>;
+    werkzeugeSpeichern: (profile: RunnerWerkzeugProfile) => Promise<void>;
+}

package/dist/runner/view-listen.d.ts

@@ -0,0 +1,32 @@
+import { Translate } from '../i18n';
+import { RunnerData } from './controller';
+import { RunnerMessageKey } from './messages';
+import { RunnerPrioritaet } from './profil';
+type T = Translate<RunnerMessageKey>;
+export interface RunnerWerkzeugZeile {
+    id: string;
+    werkzeug: string;
+    bereich: string;
+    imImage: string;
+    aktiv: boolean;
+    zeitlimit: string;
+    prioritaet: string;
+}
+export interface RunnerWerkzeugGruppe {
+    profil: string;
+    titel: string;
+    zeilen: RunnerWerkzeugZeile[];
+}
+export declare function runnerWerkzeugGruppen(state: RunnerData, t: T): RunnerWerkzeugGruppe[];
+export declare function runnerWerkzeugeGeaendert(state: RunnerData): boolean;
+export interface RunnerPrioritaetZeile extends RunnerPrioritaet {
+    index: number;
+    rangText: string;
+    hoch: string;
+    runter: string;
+    ersteZeile: boolean;
+    letzteZeile: boolean;
+}
+export declare function runnerPrioritaetZeilen(state: RunnerData, t: T): RunnerPrioritaetZeile[];
+export declare function runnerWeichtZuerstText(state: RunnerData, t: T): string;
+export {};

package/dist/runner/view.d.ts

@@ -0,0 +1,95 @@
+import { Translate } from '../i18n';
+import { RunnerData } from './controller';
+import { RunnerMessageKey } from './messages';
+import { RunnerFeldArt } from './eingabe';
+import { RunnerPfad } from './profil';
+import { RunnerAnsicht, RunnerDateiAenderung, RunnerProblem, RunnerStatus } from './types';
+type T = Translate<RunnerMessageKey>;
+export interface RunnerTab {
+    id: RunnerAnsicht;
+    label: string;
+    selected: boolean;
+}
+export declare function runnerTabs(state: RunnerData, t: T): RunnerTab[];
+/** Nächster Reiter für Pfeiltasten (zyklisch). */
+export declare function runnerNachbarTab(aktuell: RunnerAnsicht, richtung: -1 | 1): RunnerAnsicht;
+export declare function runnerNurLesen(state: RunnerData): boolean;
+export declare function runnerIstGeaendert(state: RunnerData): boolean;
+export declare function runnerMeta(state: RunnerData, t: T): string;
+export interface RunnerHinweis {
+    ton: 'danger' | 'warning' | 'info';
+    text: string;
+}
+export declare function runnerHinweise(state: RunnerData, t: T): RunnerHinweis[];
+export interface RunnerEintrag {
+    label: string;
+    wert: string;
+}
+export declare function runnerUeberblick(status: RunnerStatus | null, t: T): RunnerEintrag[];
+export interface RunnerKlassenZeile {
+    name: string;
+    aktiv: boolean;
+    soll: string;
+    max: string;
+    instanzen: string;
+    registriert: string;
+    belegt: string;
+    warteschlange: string;
+    gruende: string;
+}
+export declare function runnerKlassenZeilen(status: RunnerStatus | null): RunnerKlassenZeile[];
+export declare function runnerHatWarteschlange(status: RunnerStatus | null): boolean;
+/** Hardware-Angaben des Rechners als Liste (Schlüssel wie vom Backend geliefert). */
+export declare function runnerHardware(hardware: Readonly<Record<string, unknown>> | null | undefined): RunnerEintrag[];
+export interface RunnerOption {
+    wert: string;
+    label: string;
+}
+export interface RunnerFeld {
+    /** Pfad in Punktschreibweise; zugleich Zuordnung der Fehlermeldungen des Backends. */
+    id: string;
+    pfad: RunnerPfad;
+    label: string;
+    art: RunnerFeldArt;
+    /** Anzeigewert für Eingabe- und Auswahlfelder. */
+    wert: string;
+    /** Zustand eines Schalters. */
+    an: boolean;
+    optionen: readonly RunnerOption[];
+    schritt: string;
+    fehler: string;
+}
+/** Umbenennen einer Klasse (nur Abschnitte vom Typ Klasse). */
+export interface RunnerKlassenName {
+    alt: string;
+    wert: string;
+    fehler: string;
+    geaendert: boolean;
+}
+export interface RunnerAbschnitt {
+    id: string;
+    titel: string;
+    felder: RunnerFeld[];
+    klasse?: RunnerKlassenName;
+}
+/** Feldpfad des Backends (`gpus[0].erlaubt`) in die Feld-ID der Ansicht (`gpus.0.erlaubt`). */
+export declare function runnerFeldId(feld: string): string;
+/** Meldungen des Backends: aus der letzten Prüfung, sonst aus dem geladenen Stand. */
+export declare function runnerProbleme(state: RunnerData): readonly RunnerProblem[];
+/** Formularabschnitte aus dem Entwurf; nur Felder, die das Profil tatsächlich enthält. */
+export declare function runnerAbschnitte(state: RunnerData, t: T): RunnerAbschnitt[];
+export interface RunnerNeueKlasse {
+    wert: string;
+    fehler: string;
+    moeglich: boolean;
+}
+/** Eingabe „Neue Klasse“ mit Prüfung wie im Backend (Fehler erst nach einer Eingabe). */
+export declare function runnerNeueKlasse(state: RunnerData, t: T): RunnerNeueKlasse;
+export interface RunnerVorschau {
+    gueltig: boolean;
+    aenderungen: readonly RunnerDateiAenderung[];
+    schritte: readonly string[];
+    rootBefehl: string;
+}
+export declare function runnerVorschau(state: RunnerData): RunnerVorschau | null;
+export {};

package/dist/samplesize/controller.d.ts

@@ -0,0 +1,33 @@
+import { RequestState, Store } from '../store';
+import { SampleSizeForm, SampleSizeIssues, StratumDraft } from './model';
+import { SampleSizeCatalogue, SampleSizePlan, SampleSizeRequest, SamplesizePort } from './types';
+export type SamplesizeBusy = 'load' | 'plan';
+export interface SamplesizeCallbacks {
+    planned?: (plan: SampleSizePlan) => void;
+    failed?: (message: string) => void;
+}
+/** Stand; `error` ist die Meldung der letzten abgelehnten Anfrage. */
+export interface SamplesizeData extends RequestState<string> {
+    catalogue: SampleSizeCatalogue | null;
+    form: SampleSizeForm;
+    issues: SampleSizeIssues;
+    plan: SampleSizePlan | null;
+}
+export interface SamplesizeSource {
+    port: () => SamplesizePort | null | undefined;
+    request?: () => SampleSizeRequest | null | undefined;
+    callbacks?: () => SamplesizeCallbacks;
+}
+export interface SamplesizeController {
+    store: Store<SamplesizeData>;
+    load: () => Promise<void>;
+    selectMethod: (id: string) => void;
+    setValue: (field: string, text: string) => void;
+    setFiniteCorrection: (on: boolean) => void;
+    setStratum: (index: number, change: Partial<StratumDraft>) => void;
+    addStratum: () => void;
+    removeStratum: (index: number) => void;
+    calculate: () => Promise<void>;
+}
+export declare const INITIAL_SAMPLESIZE: SamplesizeData;
+export declare function createSamplesizeController(source: SamplesizeSource): SamplesizeController;

package/dist/samplesize/index.d.ts

@@ -0,0 +1,7 @@
+export { samplesizeMessages, type SamplesizeMessageKey } from './messages';
+export type * from './types';
+export { createSamplesizeMemoryPort, createSamplesizeRestPort } from './port';
+export { buildRequest, EMPTY_FORM, EMPTY_STRATUM, formFor, formFromRequest, hasFiniteCorrection, hasStrata, methodById, scalarFields } from './model';
+export type { SampleSizeForm, SampleSizeIssues, StratumColumn, StratumDraft } from './model';
+export * from './controller';
+export * from './view';

package/dist/samplesize/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte von SampleSizePlanner (Vue) und FlowauditSampleSizePlanner (React); sichtbare Texte nur hier. */
+export declare const samplesizeMessages: import('..').Catalogs<"loading" | "source" | "title" | "invalid" | "method" | "yes" | "no" | "required" | "result" | "failed" | "choose" | "optional" | "calculate" | "interval" | "derivation" | "stepFormula" | "stepValue" | "sampleSize" | "allocation" | "stratumPopulation" | "confidence_level" | "population_size" | "strata" | "stratumName" | "addStratum" | "warnings" | "book_value" | "factor_profile" | "materiality_rate" | "calculating" | "anticipated_error_rate" | "error_sd" | "error_rate_sd" | "finite_population_correction" | "rule" | "assurance_level" | "stratumBookValue" | "stratumSd" | "stratumExhaustive" | "stratumRow" | "removeStratum" | "rawSize" | "allocationSize" | "allocationShare" | "allocationCutOff" | "stepLabel" | "stepSource">;
+export type SamplesizeMessageKey = keyof typeof samplesizeMessages.de;

package/dist/samplesize/model.d.ts

@@ -0,0 +1,40 @@
+import { SampleSizeCatalogue, SampleSizeMethod, SampleSizeRequest } from './types';
+export interface StratumDraft {
+    name: string;
+    populationSize: string;
+    bookValue: string;
+    sd: string;
+    exhaustive: boolean;
+}
+export interface SampleSizeForm {
+    methodId: string;
+    values: Readonly<Record<string, string>>;
+    finiteCorrection: boolean;
+    strata: readonly StratumDraft[];
+}
+/** Feldschlüssel → Fehlerart (`required` oder `invalid`). */
+export type SampleSizeIssues = Readonly<Record<string, 'required' | 'invalid'>>;
+export type StratumColumn = 'name' | 'populationSize' | 'bookValue' | 'sd' | 'exhaustive';
+export declare const EMPTY_FORM: SampleSizeForm;
+export declare const EMPTY_STRATUM: StratumDraft;
+/** Felder mit Auswahlliste; alle übrigen skalaren Felder sind Zahlen. */
+export declare const CHOICE_FIELDS: readonly string[];
+/** In Prozent erfasste Anteile. */
+export declare const PERCENT_FIELDS: readonly string[];
+export declare function methodById(catalogue: SampleSizeCatalogue | null, id: string): SampleSizeMethod | null;
+/** Einzelne Eingabefelder der Methode in der Reihenfolge des Katalogs. */
+export declare function scalarFields(method: SampleSizeMethod | null): string[];
+export declare function hasStrata(method: SampleSizeMethod | null): boolean;
+export declare function hasFiniteCorrection(method: SampleSizeMethod | null): boolean;
+/** Spalten der Schichttabelle: MUS nach Buchwert, sonst nach Anzahl mit Vollerhebung. */
+export declare function strataColumns(method: SampleSizeMethod | null): StratumColumn[];
+/** Anfangswerte bei Methodenwechsel: sichtbar vorbelegt ist nur die Wesentlichkeit von 2 %. */
+export declare function formFor(method: SampleSizeMethod | null, catalogue: SampleSizeCatalogue | null): SampleSizeForm;
+/** Anfrage aus dem Formular oder die Felder mit fehlenden bzw. ungültigen Angaben. */
+export declare function buildRequest(form: SampleSizeForm, method: SampleSizeMethod): {
+    request: SampleSizeRequest;
+} | {
+    issues: SampleSizeIssues;
+};
+/** Formular aus einer Anfrage (Vorbelegung über die Eigenschaft `request`). */
+export declare function formFromRequest(request: SampleSizeRequest, catalogue: SampleSizeCatalogue | null): SampleSizeForm;

package/dist/samplesize/port.d.ts

@@ -0,0 +1,9 @@
+import { RestOptions } from '@auditcore/common';
+import { SampleSizeCatalogue, SampleSizePlan, SamplesizePort } from './types';
+/** Port auf den REST-Vertrag `auditcore_sampling.guidance/1` (Starlette oder FastAPI). */
+export declare function createSamplesizeRestPort(options: RestOptions): SamplesizePort;
+/**
+ * Port im Arbeitsspeicher (Demo, Tests): feste Antworten je Methode; ohne
+ * Antwort wird die Anfrage wie vom Backend abgelehnt.
+ */
+export declare function createSamplesizeMemoryPort(catalogue: SampleSizeCatalogue, plans?: Readonly<Record<string, SampleSizePlan>>): SamplesizePort;