@auditcore/ui-core 0.3.0

package/dist/account/camera.d.ts

@@ -0,0 +1,8 @@
+/** Opt-in Kamera, keine Aufnahme ohne Benutzeraktion, Tracks immer schließen. */
+export declare function createAccountCamera(): {
+    stop: () => void;
+    start(video: HTMLVideoElement): Promise<void>;
+    capture(video: HTMLVideoElement): Promise<Blob>;
+};
+/** Quadratischer Zuschnitt: Position 0..1 und Zoom 1..4, Metadaten übernimmt der Server nicht. */
+export declare function cropAccountImage(file: Blob, zoom: number, x: number, y: number): Promise<Blob>;

package/dist/account/controller.d.ts

@@ -0,0 +1,30 @@
+import { RequestState } from '../store';
+import { AccountDocument, AccountItem, AccountPort } from './types';
+export interface AccountCallbacks {
+    selected?: (item: AccountItem) => void;
+    failed?: (message: string) => void;
+}
+export interface AccountData extends RequestState<string> {
+    items: readonly AccountItem[];
+    selectedId: string | null;
+    document: AccountDocument | null;
+    draft: Readonly<Record<string, string>>;
+    dirty: boolean;
+    images: Readonly<Record<string, string>>;
+}
+export interface AccountSource {
+    port: () => AccountPort | null | undefined;
+    callbacks?: () => AccountCallbacks;
+}
+export declare const INITIAL_ACCOUNT: AccountData;
+export declare function createAccountController(source: AccountSource): {
+    store: import('..').Store<AccountData>;
+    dispose(): void;
+    load(): Promise<void>;
+    select(id: string): Promise<void>;
+    edit(id: string, value: string): void;
+    discard(): void;
+    save(): Promise<void>;
+    upload(fieldId: string, file: Blob): Promise<void>;
+};
+export type AccountController = ReturnType<typeof createAccountController>;

package/dist/account/index.d.ts

@@ -0,0 +1,7 @@
+export { accountMessages, type AccountMessageKey } from './messages';
+export type * from './types';
+export * from './port';
+export * from './camera';
+export * from './presentation';
+export * from './controller';
+export * from './view';

package/dist/account/messages.d.ts

@@ -0,0 +1,2 @@
+export declare const accountMessages: import('..').Catalogs<"loading" | "title" | "readonly" | "stop" | "empty" | "save" | "discard" | "saved" | "preview" | "failed" | "choose" | "zoom" | "remove" | "upload" | "crop" | "horizontal" | "vertical" | "dirty" | "camera" | "capture" | "cameraFailed">;
+export type AccountMessageKey = keyof typeof accountMessages.de;

package/dist/account/port.d.ts

@@ -0,0 +1,10 @@
+import { AccountDocument, AccountItem, AccountPort } from './types';
+/** Nur synthetische Demo/Testdaten; keine Autorisierungs- oder Persistenzschicht. */
+export declare function createAccountMemoryPort(items: readonly AccountItem[], documents?: readonly AccountDocument[]): AccountPort;
+/** Der injizierte Transport ergänzt Session, CSRF und Fehlerabbildung der Anwendung. */
+export interface AccountTransport {
+    request: <T>(method: 'GET' | 'POST', path: string, body?: unknown) => Promise<T>;
+    upload?: AccountPort['upload'];
+    imageUrl?: AccountPort['imageUrl'];
+}
+export declare function createAccountRestPort(transport: AccountTransport, base?: string): AccountPort;

package/dist/account/presentation.d.ts

@@ -0,0 +1,9 @@
+import { AccountDocument, AccountPort } from './types';
+/** Keine beliebigen CSS-Werte aus editierbaren Feldern einsetzen. */
+export declare function accountPreviewStyle(values: Readonly<Record<string, string>>): {
+    backgroundColor: string | undefined;
+    color: string | undefined;
+    fontFamily: string | undefined;
+};
+export declare function accountImageUrl(port: AccountPort | null | undefined, id: string): string;
+export declare function accountWelcomePreview(document: AccountDocument, values: Readonly<Record<string, string>>): string;

package/dist/account/types.d.ts

@@ -0,0 +1,42 @@
+/** Frameworkunabhängiger Formularvertrag; Feldrechte kommen vom Server. */
+export interface AccountItem {
+    id: string;
+    label: string;
+    group?: string;
+}
+export interface AccountField {
+    id: string;
+    label: string;
+    type?: 'text' | 'email' | 'url' | 'password' | 'textarea' | 'select' | 'multiselect' | 'color' | 'image';
+    required?: boolean;
+    readonly?: boolean;
+    hint?: string;
+    options?: readonly {
+        value: string;
+        label: string;
+    }[];
+    autocomplete?: string;
+}
+export interface AccountDocument {
+    id: string;
+    title: string;
+    description: string;
+    kind: 'profile' | 'branding' | 'welcome' | 'security' | 'admin' | 'extension';
+    revision: number;
+    fields: readonly AccountField[];
+    values: Readonly<Record<string, string>>;
+    submitLabel?: string;
+    editable: boolean;
+}
+export interface AccountImage {
+    id: string;
+    url: string;
+}
+export interface AccountPort {
+    list: () => Promise<readonly AccountItem[]>;
+    read: (id: string) => Promise<AccountDocument>;
+    save: (id: string, revision: number, values: Readonly<Record<string, string>>) => Promise<AccountDocument>;
+    /** Host autorisiert Dokument und Feld und liefert eine zugriffsgeschützte Bild-URL. */
+    upload?: (documentId: string, fieldId: string, file: Blob) => Promise<AccountImage>;
+    imageUrl?: (assetId: string) => string;
+}

package/dist/account/view.d.ts

@@ -0,0 +1,12 @@
+import { AccountData } from './controller';
+import { AccountItem } from './types';
+/** Zeile der Liste, wie Vue und React sie darstellen. */
+export interface AccountRow {
+    id: string;
+    label: string;
+    selected: boolean;
+}
+export declare function accountRows(state: AccountData): AccountRow[];
+export declare function accountSelection(state: AccountData): AccountItem | null;
+/** Hinweis „keine Einträge“ nur nach abgeschlossener, fehlerfreier Anfrage. */
+export declare function accountIsEmpty(state: AccountData): boolean;

package/dist/attributes/controller.d.ts

@@ -0,0 +1,26 @@
+import { RequestState, Store } from '../store';
+import { AttributesCatalogue, AttributesPort, AttributesResult } from './types';
+import { AttributesForm, AttributesIssues } from './view';
+export interface AttributesCallbacks {
+    evaluated?: (result: AttributesResult) => void;
+    failed?: (message: string) => void;
+}
+/** Stand; `error` ist die Meldung der letzten abgelehnten Anfrage. */
+export interface AttributesData extends RequestState<string> {
+    catalogue: AttributesCatalogue | null;
+    form: AttributesForm;
+    issues: AttributesIssues;
+    result: AttributesResult | null;
+}
+export interface AttributesSource {
+    port: () => AttributesPort | null | undefined;
+    callbacks?: () => AttributesCallbacks;
+}
+export interface AttributesController {
+    store: Store<AttributesData>;
+    load: () => Promise<void>;
+    update: (patch: Partial<AttributesForm>) => void;
+    evaluate: () => Promise<void>;
+}
+export declare const INITIAL_ATTRIBUTES: AttributesData;
+export declare function createAttributesController(source: AttributesSource): AttributesController;

package/dist/attributes/index.d.ts

@@ -0,0 +1,5 @@
+export { attributesMessages, type AttributesMessageKey } from './messages';
+export type * from './types';
+export { createAttributesRestPort } from './port';
+export * from './controller';
+export * from './view';

package/dist/attributes/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte von AttributeSampling (Vue) und FlowauditAttributeSampling (React); sichtbare Texte nur hier. */
+export declare const attributesMessages: import('..').Catalogs<"loading" | "notice" | "title" | "threshold" | "failed" | "choose" | "fingerprint" | "confidence" | "derivation" | "sampleSize" | "colValue" | "critical" | "factorProfile" | "evaluate" | "issueRequired" | "issueInvalid" | "issueRange" | "formIncomplete" | "resultTitle" | "tolerable" | "precision" | "upperLimit" | "colStep" | "colFormula" | "colSource" | "rate" | "approach" | "approachnormal" | "approachdiscovery" | "approachstop_or_go" | "deviations" | "conclusionsupported" | "conclusionnot_supported" | "conclusioncriterion_met" | "conclusiondeviation_found" | "conclusionstop" | "conclusiongo">;
+export type AttributesMessageKey = keyof typeof attributesMessages.de;

package/dist/attributes/port.d.ts

@@ -0,0 +1,4 @@
+import { RestOptions } from '@auditcore/common';
+import { AttributesPort } from './types';
+/** Port auf `auditcore_extrapolation.web` (`GET /profiles`, `POST /attributes`). */
+export declare function createAttributesRestPort(options: RestOptions): AttributesPort;

package/dist/attributes/types.d.ts

@@ -0,0 +1,60 @@
+/** Typen des REST-Endpunkts `POST /attributes` (Vertrag `auditcore_extrapolation.evaluation/1`, Leitfaden 7.9). */
+export type AttributeApproach = 'normal' | 'discovery' | 'stop_or_go';
+export interface AttributesCatalogue {
+    contract: string;
+    library: string;
+    factor_profiles: readonly {
+        id: string;
+        label: string;
+    }[];
+    recommended_profile: string;
+    confidence_levels: {
+        z: readonly number[];
+    };
+    attribute_approaches?: readonly {
+        id: AttributeApproach;
+        label: string;
+        source: string;
+    }[];
+}
+export interface AttributesRequest {
+    approach: AttributeApproach;
+    deviations: number;
+    sample_size: number;
+    confidence_level: number;
+    /** Nur Normalapproximation (z-Wert). */
+    factor_profile?: string;
+    /** Tolerierbare bzw. kritische Abweichungsquote als Anteil. */
+    tolerable_rate: number;
+}
+export interface AttributesStep {
+    label: string;
+    formula: string;
+    value: number;
+    source: string;
+}
+export type AttributesConclusion = 'supported' | 'not_supported' | 'criterion_met' | 'deviation_found' | 'stop' | 'go';
+export interface AttributesOutcome {
+    approach: AttributeApproach;
+    deviations: number;
+    sample_size: number;
+    confidence_level: number;
+    rate: number;
+    upper_limit: number;
+    conclusion: AttributesConclusion;
+    steps: readonly AttributesStep[];
+    precision?: number;
+    tolerable_rate?: number;
+    threshold?: number;
+}
+export interface AttributesResult {
+    contract: string;
+    library: string;
+    fingerprint: string;
+    attributes: AttributesOutcome;
+}
+/** Fachlogik hinter der Oberfläche; Standardumsetzung: `createAttributesRestPort`. */
+export interface AttributesPort {
+    profiles: () => Promise<AttributesCatalogue>;
+    evaluate: (request: AttributesRequest) => Promise<AttributesResult>;
+}

package/dist/attributes/view.d.ts

@@ -0,0 +1,49 @@
+import { TableColumn, TableRow } from '@auditcore/common';
+import { BadgeTone } from '../base/types';
+import { Locale, Translate } from '../i18n';
+import { AttributesMessageKey } from './messages';
+import { AttributeApproach, AttributesCatalogue, AttributesConclusion, AttributesRequest, AttributesResult } from './types';
+export type AttributesTranslate = Translate<AttributesMessageKey>;
+export interface AttributesForm {
+    approach: AttributeApproach;
+    deviations: string;
+    sampleSize: string;
+    confidence: number | null;
+    profileId: string | null;
+    /** Tolerierbare bzw. kritische Quote in Prozent. */
+    rate: string;
+}
+export type AttributesIssue = 'required' | 'invalid' | 'range';
+export type AttributesIssues = Readonly<Record<string, AttributesIssue>>;
+export type AttributesValidation = {
+    ok: true;
+    request: AttributesRequest;
+} | {
+    ok: false;
+    issues: AttributesIssues;
+};
+export declare const EMPTY_ATTRIBUTES_FORM: AttributesForm;
+export declare function attributesApproachChoices(t: AttributesTranslate): {
+    id: AttributeApproach;
+    label: string;
+}[];
+/** Anfrage für `POST /attributes`; bei Befunden die Feldschlüssel mit ihrem Fehler. */
+export declare function buildAttributesRequest(form: AttributesForm): AttributesValidation;
+export declare function attributesConfidenceChoices(catalogue: AttributesCatalogue | null): readonly number[];
+export declare function attributesPercent(value: number, locale: Locale): string;
+export declare function attributesIssueKey(issue: AttributesIssue): AttributesMessageKey;
+export declare function attributesConclusionTone(conclusion: AttributesConclusion): BadgeTone;
+export interface AttributesMetric {
+    id: string;
+    label: string;
+    value: string;
+}
+export declare function attributesMetrics(result: AttributesResult, t: AttributesTranslate, locale: Locale): AttributesMetric[];
+export declare function attributesStepColumns(t: AttributesTranslate, locale: Locale): TableColumn[];
+export declare function attributesStepRows(result: AttributesResult): TableRow[];
+export declare const ATTRIBUTE_FIELDS: readonly {
+    key: 'deviations' | 'sampleSize' | 'rate';
+    numeric: true;
+}[];
+export declare function attributesFieldLabel(key: 'deviations' | 'sampleSize' | 'rate', approach: AttributeApproach, t: AttributesTranslate): string;
+export declare function attributesFormMessage(issues: AttributesIssues, t: AttributesTranslate): string;

package/dist/base/icons.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Eigene Strichsymbole (24er-Raster, Strichstärke über CSS). Jede Zeile ist
+ * eine Liste von SVG-Pfaden; neue Symbole nur hier ergänzen.
+ */
+export declare const ICONS: {
+    readonly close: readonly ["M6 6l12 12", "M18 6L6 18"];
+    readonly plus: readonly ["M12 5v14", "M5 12h14"];
+    readonly minus: readonly ["M5 12h14"];
+    readonly check: readonly ["M5 12.5l4.5 4.5L19 7.5"];
+    readonly search: readonly ["M10.5 17a6.5 6.5 0 1 0 0-13 6.5 6.5 0 0 0 0 13z", "M15.5 15.5L20 20"];
+    readonly filter: readonly ["M4 5h16", "M7 12h10", "M10 19h4"];
+    readonly settings: readonly ["M4 6h9", "M17 6h3", "M15 4v4", "M4 12h3", "M11 12h9", "M9 10v4", "M4 18h11", "M19 18h1", "M17 16v4"];
+    readonly share: readonly ["M6 14a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z", "M18 8a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z", "M18 21a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z", "M8.2 10.4l7.6-4.3", "M8.2 12.6l7.6 4.3"];
+    readonly trash: readonly ["M4 7h16", "M9 7V4.5h6V7", "M6.5 7l1 13h9l1-13", "M10 11v6", "M14 11v6"];
+    readonly edit: readonly ["M4 20h4L19 9l-4-4L4 16v4z", "M13.5 6.5l4 4"];
+    readonly 'chevron-down': readonly ["M6 9l6 6 6-6"];
+    readonly 'chevron-up': readonly ["M6 15l6-6 6 6"];
+    readonly 'chevron-left': readonly ["M15 6l-6 6 6 6"];
+    readonly 'chevron-right': readonly ["M9 6l6 6-6 6"];
+    readonly sort: readonly ["M8 4v16", "M4.5 7.5L8 4l3.5 3.5", "M16 20V4", "M12.5 16.5L16 20l3.5-3.5"];
+    readonly 'sort-asc': readonly ["M12 19V5", "M6.5 10.5L12 5l5.5 5.5"];
+    readonly 'sort-desc': readonly ["M12 5v14", "M6.5 13.5L12 19l5.5-5.5"];
+    readonly grip: readonly ["M9 6h.01", "M15 6h.01", "M9 12h.01", "M15 12h.01", "M9 18h.01", "M15 18h.01"];
+    readonly calendar: readonly ["M4.5 6.5h15v13h-15z", "M4.5 10.5h15", "M8.5 4v4", "M15.5 4v4"];
+    readonly clock: readonly ["M12 20.5a8.5 8.5 0 1 0 0-17 8.5 8.5 0 0 0 0 17z", "M12 7.5V12l3 2"];
+    readonly paperclip: readonly ["M19 11.5l-7.2 7.2a4.5 4.5 0 0 1-6.4-6.4l7.8-7.8a3 3 0 0 1 4.2 4.2l-7.6 7.6a1.5 1.5 0 0 1-2.1-2.1l6.9-6.9"];
+    readonly user: readonly ["M12 12a4 4 0 1 0 0-8 4 4 0 0 0 0 8z", "M4.5 20.5a7.5 7.5 0 0 1 15 0"];
+    readonly lock: readonly ["M6 11h12v9H6z", "M8.5 11V8a3.5 3.5 0 0 1 7 0v3"];
+    readonly pin: readonly ["M9 4h6l-1 6 3 3H7l3-3-1-6z", "M12 13v7"];
+    readonly sun: readonly ["M12 16.5a4.5 4.5 0 1 0 0-9 4.5 4.5 0 0 0 0 9z", "M12 2.5v2", "M12 19.5v2", "M2.5 12h2", "M19.5 12h2", "M5.3 5.3l1.4 1.4", "M17.3 17.3l1.4 1.4", "M5.3 18.7l1.4-1.4", "M17.3 6.7l1.4-1.4"];
+    readonly moon: readonly ["M19.5 14.5A8 8 0 0 1 9.5 4.5a8 8 0 1 0 10 10z"];
+    readonly warning: readonly ["M12 4l9 16H3z", "M12 10v4.5", "M12 17.5h.01"];
+    readonly info: readonly ["M12 20.5a8.5 8.5 0 1 0 0-17 8.5 8.5 0 0 0 0 17z", "M12 11v5.5", "M12 7.5h.01"];
+    readonly expand: readonly ["M4 9V4h5", "M20 9V4h-5", "M4 15v5h5", "M20 15v5h-5"];
+    readonly 'more-vertical': readonly ["M12 5.5h.01", "M12 12h.01", "M12 18.5h.01"];
+};
+export type IconName = keyof typeof ICONS;
+export declare function isIconName(value: string): value is IconName;

package/dist/base/index.d.ts

@@ -0,0 +1,3 @@
+/** Kern der Basiskomponenten (Schaltfläche, Symbol, Abzeichen): Symbole und Varianten, ohne Zustand. */
+export { ICONS, isIconName, type IconName } from './icons';
+export type { BadgeTone, ButtonSize, ButtonVariant } from './types';

package/dist/base/types.d.ts

@@ -0,0 +1,3 @@
+export type BadgeTone = 'neutral' | 'accent' | 'success' | 'warning' | 'danger';
+export type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger';
+export type ButtonSize = 'sm' | 'md';

package/dist/batchchecks/controller.d.ts

@@ -0,0 +1,60 @@
+import { DecimalSeparator, DownloadFile } from '@auditcore/common';
+import { RequestState, Store } from '../store';
+import { BatchchecksError, BatchchecksMapping } from './model';
+import { BatchchecksAnswer, BatchchecksCatalogue, BatchchecksDocument, BatchchecksExportFormat, BatchchecksPort, BatchchecksRequest } from './types';
+export type BatchchecksBusy = 'load' | 'run' | 'export';
+export interface BatchchecksCallbacks {
+    completed?: (answer: BatchchecksAnswer) => void;
+    failed?: (message: string) => void;
+}
+/** Stand; `error` ist die Meldung der letzten abgelehnten Anfrage. */
+export interface BatchchecksData extends RequestState<string> {
+    catalogue: BatchchecksCatalogue | null;
+    /** Belege aus einer JSON-Datei (sonst gilt die Tabelle des TableImport-Controllers). */
+    json: readonly BatchchecksDocument[] | null;
+    jsonName: string;
+    mapping: BatchchecksMapping;
+    totalVolume: string;
+    supplementary: boolean;
+    validation: BatchchecksError | null;
+    request: BatchchecksRequest | null;
+    answer: BatchchecksAnswer | null;
+    /** Regel, deren Befunde angezeigt werden (`null` = alle). */
+    ruleFilter: string | null;
+}
+export interface BatchchecksSource {
+    port: () => BatchchecksPort | null | undefined;
+    callbacks?: () => BatchchecksCallbacks;
+}
+export declare const INITIAL_BATCHCHECKS: BatchchecksData;
+export declare function createBatchchecksController(source: BatchchecksSource): {
+    setTotalVolume: (totalVolume: string) => void;
+    setSupplementary: (supplementary: boolean) => void;
+    setRuleFilter: (ruleFilter: string | null) => void;
+    /** Vorhandenes Ergebnis anzeigen (Eigenschaft `result`). */
+    showAnswer: (answer: BatchchecksAnswer | null) => void;
+    /** Dateiinhalt übernehmen (Datei bereits gelesen, z. B. Beispielbestand). */
+    loadText: (filename: string, text: string) => void;
+    readFile: (file: File) => Promise<void>;
+    setHasHeader: (hasHeader: boolean) => void;
+    setDecimal: (decimal: DecimalSeparator) => void;
+    /** Feld einer Spalte zuordnen (`null` = keine). */
+    setColumn: (field: string, column: number | null) => void;
+    store: Store<BatchchecksData>;
+    /** Tabellenimport (gemeinsamer TableImport-Controller aus `@auditcore/ui-core`). */
+    table: {
+        store: Store<import('..').TableImportData>;
+        load: (filename: string, text: string) => void;
+        reparse: () => void;
+        read: (file: File) => Promise<void>;
+        setHasHeader: (hasHeader: boolean) => void;
+        setValueColumn: (valueColumn: number) => void;
+        setIdColumn: (idColumn: number | null) => void;
+        setStratumColumn: (stratumColumn: number | null) => void;
+        setDecimal: (decimal: DecimalSeparator) => void;
+    };
+    load: () => Promise<void>;
+    check: () => Promise<void>;
+    exportRun: (format: BatchchecksExportFormat) => Promise<DownloadFile | null>;
+};
+export type BatchchecksController = ReturnType<typeof createBatchchecksController>;

package/dist/batchchecks/index.d.ts

@@ -0,0 +1,7 @@
+export { batchchecksMessages, type BatchchecksMessageKey } from './messages';
+export type * from './types';
+export { createBatchchecksMemoryPort } from './port';
+export { createBatchchecksRestPort } from './rest-port';
+export * from './model';
+export * from './controller';
+export * from './view';

package/dist/batchchecks/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte der Bestandsprüfung: BatchChecks (Vue) und FlowauditBatchChecks (React); sichtbare Texte nur hier. */
+export declare const batchchecksMessages: import('..').Catalogs<"loading" | "notice" | "header" | "input" | "summary" | "title" | "decimal" | "none" | "noPort" | "exportCsv" | "colStatus" | "columns" | "result" | "failed" | "colCode" | "run" | "file" | "decimalComma" | "decimalDot" | "colId" | "exportJson" | "errortooMany" | "metrics" | "tableSummary" | "errornoRows" | "fileHelp" | "noValue" | "findings" | "findingsNone" | "colMessage" | "jsonSummary" | "totalVolume" | "totalVolumeHelp" | "supplementary" | "errornoData" | "errornoColumns" | "errorjson" | "errortotalVolume" | "escalation" | "levelinfo" | "levelwarning" | "levelblocker" | "blocked" | "rules" | "colTitle" | "colChecks" | "statuspassed" | "statusfindings" | "statusnot_checked" | "statusresult" | "supplement" | "filterRule" | "allRules" | "colLevel" | "colAffected" | "colBasis" | "inventoryWide" | "more" | "metricMandatory" | "metricFormal" | "metricErrors" | "metricOcrAvg" | "metricOcrMin">;
+export type BatchchecksMessageKey = keyof typeof batchchecksMessages.de;

package/dist/batchchecks/model.d.ts

@@ -0,0 +1,38 @@
+import { DecimalSeparator, ParsedTable } from '@auditcore/common';
+import { BatchchecksCatalogue, BatchchecksDocument, BatchchecksField, BatchchecksRequest } from './types';
+export type BatchchecksError = 'noData' | 'noRows' | 'tooMany' | 'noColumns' | 'json' | 'totalVolume';
+export type BatchchecksValidation = {
+    ok: true;
+    request: BatchchecksRequest;
+} | {
+    ok: false;
+    error: BatchchecksError;
+};
+/** Feld → Spalte der Tabelle (`null` = nicht zugeordnet). */
+export type BatchchecksMapping = Readonly<Record<string, number | null>>;
+/** Spalten automatisch zuordnen: Spaltenname gleich Feldkennung oder einem Spaltennamen des Katalogs; jede Spalte höchstens einmal. */
+export declare function batchchecksAutoMapping(fields: readonly BatchchecksField[], header: readonly string[]): Record<string, number | null>;
+/** Dezimaltrennzeichen aus den Zellen aller zugeordneten Zahlenspalten. */
+export declare function batchchecksDecimal(table: ParsedTable, fields: readonly BatchchecksField[], mapping: BatchchecksMapping): DecimalSeparator;
+/** Dateiinhalt als JSON behandeln (Endung `.json` oder beginnt mit `[`/`{`). */
+export declare function batchchecksLooksLikeJson(filename: string, text: string): boolean;
+/**
+ * Belege aus einer JSON-Datei: Liste, `{"documents": [...]}` oder ein
+ * einzelner Lauf der Belegerkennung; `null`, wenn die Datei das nicht ist.
+ */
+export declare function batchchecksJsonDocuments(text: string): BatchchecksDocument[] | null;
+/** Zelle als Wert: leer → `null`, Zahlenfelder als Zahl (Prozentangaben der OCR-Konfidenz als Anteil), Unlesbares unverändert. */
+export declare function batchchecksCellValue(cell: string, field: BatchchecksField, decimal: DecimalSeparator): string | number | null;
+/** Tabellenzeilen als Belege (nur zugeordnete Felder). */
+export declare function batchchecksTableDocuments(table: ParsedTable, mapping: BatchchecksMapping, fields: readonly BatchchecksField[], decimal: DecimalSeparator): BatchchecksDocument[];
+export interface BatchchecksInput {
+    catalogue: BatchchecksCatalogue;
+    table: ParsedTable | null;
+    json: readonly BatchchecksDocument[] | null;
+    mapping: BatchchecksMapping;
+    decimal: DecimalSeparator;
+    totalVolume: string;
+    supplementary: boolean;
+}
+/** Anfrage für `POST /runs` aus Datei, Zuordnung und Optionen. */
+export declare function buildBatchchecksRequest(input: BatchchecksInput): BatchchecksValidation;

package/dist/batchchecks/port.d.ts

@@ -0,0 +1,6 @@
+import { BatchchecksAnswer, BatchchecksCatalogue, BatchchecksPort } from './types';
+/**
+ * Port mit festen Antworten (Demo ohne Server, Tests): Katalog und Antwort
+ * wie vom Dienst; der Export liefert die Antwort als JSON-Datei.
+ */
+export declare function createBatchchecksMemoryPort(catalogue: BatchchecksCatalogue, answer: BatchchecksAnswer): BatchchecksPort;

package/dist/batchchecks/rest-port.d.ts

@@ -0,0 +1,4 @@
+import { RestOptions } from '@auditcore/common';
+import { BatchchecksPort } from './types';
+/** Port auf den REST-Vertrag `documents_batch_checks/1` von `auditcore_documents.web` (Starlette oder FastAPI). */
+export declare function createBatchchecksRestPort(options: RestOptions): BatchchecksPort;

package/dist/batchchecks/types.d.ts

@@ -0,0 +1,121 @@
+import { DownloadFile } from '@auditcore/common';
+export type BatchchecksLevel = 'info' | 'warning' | 'blocker';
+export type BatchchecksRuleStatus = 'passed' | 'findings' | 'not_checked' | 'result';
+export type BatchchecksScope = 'document' | 'inventory' | 'run';
+export type BatchchecksExportFormat = 'json' | 'csv';
+/** Prüfregel des Katalogs: was geprüft wird, Rechtsgrundlage, Herkunft. */
+export interface BatchchecksRule {
+    code: string;
+    title: string;
+    checks: string;
+    legal_basis: string;
+    scope: BatchchecksScope;
+    source: string;
+}
+/** Feld des Bestands mit Spaltennamen für die automatische Zuordnung. */
+export interface BatchchecksField {
+    name: string;
+    label: string;
+    aliases: readonly string[];
+    numeric: boolean;
+}
+export interface BatchchecksOptions {
+    total_volume: number | null;
+    tolerance: number;
+    concentration_threshold: number;
+    block_threshold: number;
+    supplementary: boolean;
+}
+export interface BatchchecksCatalogue {
+    contract: string;
+    library: string;
+    rules: readonly BatchchecksRule[];
+    fields: readonly BatchchecksField[];
+    defaults: BatchchecksOptions;
+    levels: readonly {
+        id: BatchchecksLevel;
+        label: string;
+    }[];
+    limits: {
+        max_documents: number;
+        max_body_bytes: number;
+    };
+    export_formats: readonly BatchchecksExportFormat[];
+    stored: boolean;
+}
+/** Beleg der Anfrage: flacher Datensatz oder Lauf der Belegerkennung (`documents_extraction/1`). */
+export type BatchchecksDocument = Readonly<Record<string, unknown>>;
+export interface BatchchecksRequest {
+    documents: readonly BatchchecksDocument[];
+    options?: Partial<BatchchecksOptions>;
+}
+export interface BatchchecksRuleResult extends BatchchecksRule {
+    status: BatchchecksRuleStatus;
+    note: string | null;
+    findings: number;
+    documents: number;
+    level: BatchchecksLevel | null;
+}
+export interface BatchchecksFinding {
+    id: string;
+    rule: string;
+    category: string;
+    level: BatchchecksLevel;
+    field: string | null;
+    /** Begründung (deutsch). */
+    message: string;
+    /** Betroffene Belege (0-basiert). */
+    documents: readonly number[];
+    evidence: Readonly<Record<string, unknown>>;
+    rule_reference: string;
+}
+export interface BatchchecksDocumentResult {
+    index: number;
+    ref: string;
+    supplier_name: string | number | null;
+    invoice_number: string | number | null;
+    invoice_date: string | number | null;
+    gross_amount: string | number | null;
+    ocr_confidence: number | null;
+    findings: number;
+    level: BatchchecksLevel | null;
+    rules: readonly string[];
+}
+export interface BatchchecksSummary {
+    documents: number;
+    findings: number;
+    documents_with_findings: number;
+    escalation_level: BatchchecksLevel;
+    report_blocked: boolean;
+    block_reason: string | null;
+    timestamp: string;
+}
+export interface BatchchecksMetrics {
+    total_documents: number;
+    mandatory_fields_success_rate: number;
+    per_field_success: Readonly<Record<string, number>>;
+    documents_with_errors: number;
+    documents_with_errors_rate: number;
+    avg_ocr_confidence: number | null;
+    min_ocr_confidence: number | null;
+    escalated_documents: number;
+    formal_correctness_rate: number;
+}
+/** Antwort von `POST /runs`. */
+export interface BatchchecksAnswer {
+    contract: string;
+    library: string;
+    options: BatchchecksOptions;
+    summary: BatchchecksSummary;
+    metrics: BatchchecksMetrics;
+    rules: readonly BatchchecksRuleResult[];
+    findings: readonly BatchchecksFinding[];
+    documents: readonly BatchchecksDocumentResult[];
+    stored: boolean;
+}
+/** Fachlogik hinter der Oberfläche; Vue und React rufen nur diesen Port auf. */
+export interface BatchchecksPort {
+    catalogue: () => Promise<BatchchecksCatalogue>;
+    run: (request: BatchchecksRequest) => Promise<BatchchecksAnswer>;
+    exportRun: (request: BatchchecksRequest, format: BatchchecksExportFormat) => Promise<DownloadFile>;
+}

package/dist/batchchecks/view.d.ts

@@ -0,0 +1,58 @@
+import { Locale, Translate } from '../i18n';
+import { TableImportData } from '../tabular';
+import { BatchchecksData } from './controller';
+import { BatchchecksMessageKey } from './messages';
+import { BatchchecksAnswer, BatchchecksFinding, BatchchecksLevel } from './types';
+export type BatchchecksTranslate = Translate<BatchchecksMessageKey>;
+export type BatchchecksTone = 'success' | 'warning' | 'danger' | 'neutral';
+/** Höchstzahl aufgezählter Belege je Befund. */
+export declare const BATCHCHECKS_LISTED_DOCUMENTS = 10;
+export declare function batchchecksLevelText(level: BatchchecksLevel | null, t: BatchchecksTranslate): string;
+export declare function batchchecksLevelTone(level: BatchchecksLevel | null): BatchchecksTone;
+/** Eine Tabelle ist geladen (und keine JSON-Datei). */
+export declare function batchchecksHasTable(state: BatchchecksData, table: TableImportData): boolean;
+/** Kurzbeschreibung der eingelesenen Datei. */
+export declare function batchchecksSourceText(state: BatchchecksData, table: TableImportData, t: BatchchecksTranslate): string;
+export interface BatchchecksColumnField {
+    name: string;
+    label: string;
+    value: number | null;
+}
+/** Auswahlfelder der Spaltenzuordnung in der Reihenfolge des Katalogs. */
+export declare function batchchecksColumnFields(state: BatchchecksData): BatchchecksColumnField[];
+export interface BatchchecksRuleRow {
+    code: string;
+    title: string;
+    checks: string;
+    basis: string;
+    supplement: boolean;
+    status: string;
+    tone: BatchchecksTone;
+    note: string;
+}
+/** Regelübersicht: alle Regeln mit Status, auch ohne Befund und nicht geprüfte. */
+export declare function batchchecksRuleRows(answer: BatchchecksAnswer, t: BatchchecksTranslate): BatchchecksRuleRow[];
+/** Regeln mit Befunden für die Filterauswahl. */
+export declare function batchchecksFilterOptions(answer: BatchchecksAnswer): {
+    code: string;
+    label: string;
+}[];
+/** Betroffene Belege als Kennungen (höchstens zehn, dann „… und n weitere“); ohne Belege „Gesamtbestand“. */
+export declare function batchchecksAffectedText(finding: BatchchecksFinding, answer: BatchchecksAnswer, t: BatchchecksTranslate): string;
+export interface BatchchecksFindingRow {
+    id: string;
+    rule: string;
+    level: string;
+    tone: BatchchecksTone;
+    message: string;
+    affected: string;
+    basis: string;
+}
+/** Befunde (wahlweise einer Regel) mit Begründung und betroffenen Belegen. */
+export declare function batchchecksFindingRows(answer: BatchchecksAnswer, ruleFilter: string | null, t: BatchchecksTranslate): BatchchecksFindingRow[];
+export declare function batchchecksSummaryText(answer: BatchchecksAnswer, t: BatchchecksTranslate): string;
+/** Kennzahlen der Extraktionsqualität (C-12). */
+export declare function batchchecksMetricRows(answer: BatchchecksAnswer, t: BatchchecksTranslate, locale: Locale): {
+    label: string;
+    value: string;
+}[];