@auditcore/ui-core 0.3.0

package/dist/samplesize/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Vertrag `auditcore_sampling.guidance/1` (Python `auditcore_sampling.web`,
+ * docs/ui/samplesize-rest.md): Stichprobenumfang nach dem KOM-Leitfaden
+ * EGESIF_16-0014-01.
+ */
+/** Tabelle, aus der die Konfidenzniveaus einer Methode stammen. */
+export type SampleSizeConfidenceTable = 'z' | 'reliability' | null;
+export interface SampleSizeMethod {
+    id: string;
+    label: string;
+    section: string;
+    formula: string;
+    fields: readonly string[];
+    source: string;
+    confidence_table: SampleSizeConfidenceTable;
+}
+export interface SampleSizeLevel {
+    level: number;
+    value: number;
+}
+export interface SampleSizeChoice {
+    id: string;
+    label: string;
+}
+export interface SampleSizeCatalogue {
+    contract: string;
+    library: string;
+    status: string;
+    status_label: string;
+    guidance: string;
+    materiality_rate: number;
+    methods: readonly SampleSizeMethod[];
+    factor_profiles: readonly (SampleSizeChoice & {
+        source: string;
+        note: string;
+    })[];
+    tables: {
+        z: readonly SampleSizeLevel[];
+        reliability: readonly SampleSizeLevel[];
+        expansion: readonly SampleSizeLevel[];
+    };
+    nonstatistical_rules: readonly (SampleSizeChoice & {
+        source: string;
+    })[];
+    assurance_levels: readonly SampleSizeChoice[];
+}
+export interface SampleSizeStratumRequest {
+    name: string;
+    population_size?: number;
+    book_value?: number;
+    sd?: number;
+    exhaustive: boolean;
+}
+/** Anfrage an `POST /guidance/size`; Anteile als Werte zwischen 0 und 1. */
+export interface SampleSizeRequest {
+    method: string;
+    [field: string]: string | number | boolean | readonly SampleSizeStratumRequest[];
+}
+export interface SampleSizeStep {
+    label: string;
+    formula: string;
+    value: number;
+    source: string;
+}
+export interface SampleSizeAllocation {
+    name: string;
+    sample_size: number;
+    exhaustive: boolean;
+    population_size: number | null;
+    book_value: number | null;
+    share: number | null;
+    cut_off: number | null;
+}
+export interface SampleSizePlan {
+    contract: string;
+    library: string;
+    status: string;
+    status_label: string;
+    method: string;
+    sample_size: number;
+    raw_size: number;
+    interval: number | null;
+    inputs: Readonly<Record<string, unknown>>;
+    strata: readonly SampleSizeAllocation[];
+    derivation: readonly SampleSizeStep[];
+    warnings: readonly string[];
+}
+/** Fachlogik hinter der Oberfläche; Vue und React rufen nur diesen Port auf. */
+export interface SamplesizePort {
+    profiles: () => Promise<SampleSizeCatalogue>;
+    plan: (request: SampleSizeRequest) => Promise<SampleSizePlan>;
+}

package/dist/samplesize/view.d.ts

@@ -0,0 +1,39 @@
+import { Locale, Translate } from '../i18n';
+import { SamplesizeData } from './controller';
+import { SamplesizeMessageKey } from './messages';
+import { StratumColumn } from './model';
+import { SampleSizeMethod, SampleSizePlan } from './types';
+type T = Translate<SamplesizeMessageKey>;
+export interface SamplesizeOption {
+    value: string;
+    label: string;
+}
+/** Ein Eingabefeld, wie Vue und React es darstellen. */
+export interface SamplesizeFieldView {
+    key: string;
+    label: string;
+    kind: 'choice' | 'number';
+    options: SamplesizeOption[];
+    value: string;
+    issue: string | null;
+    inputMode: 'decimal' | 'numeric';
+}
+export interface SamplesizeCell {
+    key: string;
+    text: string;
+}
+export declare function samplesizeMethod(state: SamplesizeData): SampleSizeMethod | null;
+/** Eingabefelder der gewählten Methode mit Beschriftung, Auswahl und Fehlermeldung. */
+export declare function samplesizeFields(state: SamplesizeData, t: T, locale: Locale): SamplesizeFieldView[];
+export declare function samplesizeStrataColumns(state: SamplesizeData, t: T): {
+    key: StratumColumn;
+    label: string;
+}[];
+/** Zahl für die Anzeige: ganze Beträge gruppiert, kleine Werte mit bis zu sechs Stellen. */
+export declare function samplesizeNumber(value: number, locale: Locale): string;
+export declare function samplesizeSummary(plan: SampleSizePlan, t: T, locale: Locale): SamplesizeCell[];
+export declare function samplesizeAllocation(plan: SampleSizePlan, t: T, locale: Locale): string[][];
+export declare function samplesizeDerivation(plan: SampleSizePlan, locale: Locale): string[][];
+/** Anteile werden in Prozent erfasst (Beschriftung „(%)“). */
+export declare const samplesizePercentFields: readonly string[];
+export {};

package/dist/sampling/controller.d.ts

@@ -0,0 +1,62 @@
+import { DownloadFile } from '@auditcore/common';
+import { RequestState } from '../store';
+import { FieldError, SelectionValidation } from './model';
+import { AllocationMethod, ExportFormat, MethodProfile, PopulationItem, SamplingCatalogue, SamplingPort, SelectionRequest, SelectionResult, SelectionVariant, SizeResult } from './types';
+export type SamplingBusy = 'load' | 'size' | 'selection' | 'export';
+export type SelectionError = Extract<SelectionValidation, {
+    ok: false;
+}>['error'];
+export interface SamplingCallbacks {
+    sizeCalculated?: (result: SizeResult) => void;
+    selectionDrawn?: (result: SelectionResult) => void;
+    failed?: (message: string) => void;
+}
+/** Stand des Stichprobenrechners; `error` ist die Meldung der letzten abgelehnten Anfrage. */
+export interface SamplingData extends RequestState<string> {
+    catalogue: SamplingCatalogue | null;
+    methodId: string;
+    texts: Record<string, string>;
+    confidence: number | null;
+    fieldErrors: Readonly<Record<string, FieldError>>;
+    size: SizeResult | null;
+    /** Importierte Grundgesamtheit; `null` = Eigenschaft `items`. */
+    imported: readonly PopulationItem[] | null;
+    sampleSize: string;
+    seed: string;
+    variant: SelectionVariant | null;
+    allocation: AllocationMethod | null;
+    selection: SelectionResult | null;
+    lastRequest: (SelectionRequest & {
+        seed: number;
+    }) | null;
+    selectionError: SelectionError | null;
+}
+export interface SamplingSource {
+    port: () => SamplingPort | null | undefined;
+    items: () => readonly PopulationItem[];
+    /** Zahl → Text im Sprachformat (Startwerte und Vorschläge der Felder). */
+    format: (value: number) => string;
+    callbacks?: () => SamplingCallbacks;
+}
+export declare const INITIAL_SAMPLING: SamplingData;
+export declare function samplingProfile(state: SamplingData): MethodProfile | null;
+export declare function samplingPopulation(state: SamplingData, items: readonly PopulationItem[]): readonly PopulationItem[];
+export declare function isStratifiedPopulation(population: readonly PopulationItem[]): boolean;
+export declare function createSamplingController(source: SamplingSource): {
+    store: import('..').Store<SamplingData>;
+    load: () => Promise<void>;
+    selectMethod: (id: string) => void;
+    applySuggestions: () => void;
+    calculate: () => Promise<void>;
+    draw: (freshSeed?: boolean) => Promise<void>;
+    exportSelection: (format: ExportFormat) => Promise<DownloadFile | null>;
+    /** Importierte Grundgesamtheit übernehmen; `null` kehrt zur Eigenschaft `items` zurück. */
+    usePopulation: (imported: readonly PopulationItem[] | null) => void;
+    setTexts: (texts: Record<string, string>) => void;
+    setConfidence: (confidence: number | null) => void;
+    setSampleSize: (sampleSize: string) => void;
+    setSeed: (seed: string) => void;
+    setVariant: (variant: SelectionVariant | null) => void;
+    setAllocation: (allocation: AllocationMethod | null) => void;
+};
+export type SamplingController = ReturnType<typeof createSamplingController>;

package/dist/sampling/index.d.ts

@@ -0,0 +1,6 @@
+export { samplingMessages, type SamplingMessageKey } from './messages';
+export * from './model';
+export { createSamplingRestPort } from './rest-port';
+export type * from './types';
+export * from './controller';
+export * from './view';

package/dist/sampling/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte des Stichprobenrechners. */
+export declare const samplingMessages: import('..').Catalogs<"loading" | "source" | "title" | "variant" | "method" | "exportCsv" | "result" | "failed" | "choose" | "colHits" | "parameters" | "confidence" | "methodHint" | "statusRECOMMENDED" | "statusSUPERSEDED" | "statusLEGACY_CHARACTERIZED" | "formula" | "confidenceOption" | "fromPopulation" | "calculate" | "errorRequired" | "errorInvalid" | "errorRange" | "rangeBetween" | "rangeFrom" | "rangeTo" | "resultSummary" | "interval" | "derivation" | "step" | "stepFormula" | "stepValue" | "population" | "populationCount" | "populationEmpty" | "strataCount" | "selection" | "sampleSize" | "allocation" | "seed" | "seedHint" | "draw" | "redraw" | "seedUsed" | "seedGenerated" | "seedGiven" | "reproducible" | "selectedSummary" | "allocationTable" | "stratum" | "stratumPopulation" | "stratumSample" | "stratumInterval" | "stratumStart" | "noStratum" | "excludedNegative" | "excludedZero" | "colOrder" | "colPosition" | "colId" | "colValue" | "colStratum" | "exportJson" | "selectionErrornoItems" | "selectionErrorsampleSize" | "selectionErrorseed" | "selectionErrorvariant" | "selectionErrorallocation" | "selectionErrorpartialStrata">;
+export type SamplingMessageKey = keyof typeof samplingMessages.de;

package/dist/sampling/model.d.ts

@@ -0,0 +1,63 @@
+import { AllocationMethod, MethodProfile, ParameterSpec, PopulationItem, SelectionRequest, SelectionVariant, SizeRequest } from './types';
+export type FieldErrorCode = 'required' | 'invalid' | 'range';
+export interface FieldError {
+    code: FieldErrorCode;
+    min?: number;
+    max?: number;
+}
+export type SizeValidation = {
+    ok: true;
+    request: SizeRequest;
+} | {
+    ok: false;
+    errors: Readonly<Record<string, FieldError>>;
+};
+/** Anteile werden in Prozent eingegeben und angezeigt. */
+export declare function isPercent(spec: ParameterSpec): boolean;
+/** Eingabetext (deutsch oder englisch notiert) → Zahl; leer → null, unlesbar → undefined. */
+export declare function parseInput(text: string): number | null | undefined;
+/** Prüft ein Eingabefeld und liefert den Vertragswert (Prozent → Anteil). */
+export declare function fieldValue(spec: ParameterSpec, text: string): {
+    value: number;
+} | {
+    error: FieldError;
+};
+/** Anfrage für `POST /size`; jedes Feld ist Pflicht, nichts wird still ergänzt. */
+export declare function buildSizeRequest(profile: MethodProfile, texts: Readonly<Record<string, string>>, confidence: number | null): SizeValidation;
+/** Vorschlagswerte aus der Grundgesamtheit (Summe positiver Werte bzw. Anzahl). */
+export declare function populationSuggestions(items: readonly PopulationItem[]): Readonly<Record<string, number>>;
+/** Startwerte der Textfelder: vorgeschlagene Werte der Profile, sonst leer. */
+export declare function initialTexts(profile: MethodProfile, formatter: (value: number) => string): Record<string, string>;
+export interface StratumCount {
+    stratum: string;
+    population: number;
+}
+/** Schichten in Reihenfolge ihres ersten Auftretens; leer, wenn kein Element geschichtet ist. */
+export declare function strataOf(items: readonly PopulationItem[]): StratumCount[];
+/** Teilweise geschichtete Grundgesamtheit (der Server lehnt sie ab). */
+export declare function hasPartialStrata(items: readonly PopulationItem[]): boolean;
+export interface SelectionInput {
+    profile: MethodProfile;
+    items: readonly PopulationItem[];
+    sampleSize: string;
+    seed: string;
+    variant: SelectionVariant | null;
+    allocation: AllocationMethod | null;
+}
+export type SelectionValidation = {
+    ok: true;
+    request: SelectionRequest;
+} | {
+    ok: false;
+    error: 'noItems' | 'sampleSize' | 'seed' | 'variant' | 'allocation' | 'partialStrata';
+};
+/** Anfrage für `POST /selection`; ein leerer Seed überlässt dem Server die Erzeugung. */
+export declare function buildSelectionRequest(input: SelectionInput): SelectionValidation;
+/** Übernommene Dateispalten → Elemente der Grundgesamtheit (Kennung sonst laufende Nummer). */
+export declare function itemsFromImport(columns: {
+    values: readonly (number | null)[];
+    ids: readonly string[] | null;
+    strata: readonly string[] | null;
+}): PopulationItem[];
+/** Summe der positiven Werte (Auswahlbasis der Variante „portal“). */
+export declare function positiveSum(items: readonly PopulationItem[]): number;

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

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

package/dist/sampling/types.d.ts

@@ -0,0 +1,136 @@
+import { DownloadFile } from '@auditcore/common';
+export type MethodKind = 'mus' | 'srs';
+export type MethodStatus = 'RECOMMENDED' | 'SUPERSEDED' | 'LEGACY_CHARACTERIZED';
+export type SelectionVariant = 'portal' | 'flowstat';
+export type AllocationMethod = 'proportional' | 'equal';
+export interface ParameterSpec {
+    key: string;
+    label: string;
+    unit: 'EUR' | 'Anteil' | 'Stück';
+    type: 'number' | 'integer' | 'choice';
+    minimum?: number;
+    maximum?: number;
+    exclusive_minimum?: number;
+    exclusive_maximum?: number;
+    suggested?: number;
+}
+export interface ConfidenceLevel {
+    level: number;
+    factor: number;
+}
+export interface MethodProfile {
+    id: string;
+    kind: MethodKind;
+    label: string;
+    status: MethodStatus;
+    recommended: boolean;
+    source: string;
+    note: string;
+    formula: string;
+    confidence_levels: readonly ConfidenceLevel[];
+    parameters: readonly ParameterSpec[];
+    default_variant: SelectionVariant | null;
+}
+export interface NamedOption<I extends string> {
+    id: I;
+    label: string;
+    description?: string;
+    formula?: string;
+}
+export interface SamplingCatalogue {
+    library: string;
+    recommended: {
+        mus: string;
+    };
+    decision: Readonly<Record<string, string>>;
+    methods: readonly MethodProfile[];
+    selection_variants: readonly NamedOption<SelectionVariant>[];
+    allocation_methods: readonly NamedOption<AllocationMethod>[];
+}
+export type SizeRequest = {
+    method: string;
+} & Readonly<Record<string, number | string>>;
+export interface DerivationStep {
+    label: string;
+    formula: string;
+    value: number;
+}
+export interface SizeResult {
+    library: string;
+    method: string;
+    kind: MethodKind;
+    status: MethodStatus;
+    sample_size: number;
+    interval: number;
+    inputs: Readonly<Record<string, number>>;
+    warnings: readonly string[];
+    derivation: readonly DerivationStep[];
+}
+export interface PopulationItem {
+    id?: string | number;
+    value: number | null;
+    stratum?: string;
+}
+export interface AllocationRequest {
+    total_sample_size: number;
+    method: AllocationMethod;
+    strata: Readonly<Record<string, number>>;
+}
+export interface AllocationResult {
+    method: AllocationMethod;
+    total_sample_size: number;
+    allocated: number;
+    strata: readonly {
+        stratum: string;
+        population: number;
+        sample_size: number;
+    }[];
+}
+export interface SelectionRequest {
+    method: MethodKind;
+    variant?: SelectionVariant;
+    items: readonly PopulationItem[];
+    sample_size: number;
+    seed?: number;
+    allocation?: AllocationMethod;
+}
+export interface SelectionRow {
+    order: number;
+    position: number;
+    id: string;
+    value: number | null;
+    stratum: string | null;
+    hits: number;
+}
+export interface StratumResult {
+    stratum: string | null;
+    population: number;
+    sample_size: number;
+    interval?: number;
+    start?: number;
+    excluded_negative?: readonly string[];
+    excluded_zero_or_missing?: readonly string[];
+}
+export interface SelectionResult {
+    library: string;
+    method: MethodKind;
+    variant: SelectionVariant | null;
+    seed: number;
+    seed_generated: boolean;
+    items_sha256: string;
+    population: number;
+    selected: number;
+    strata: readonly StratumResult[];
+    rows: readonly SelectionRow[];
+}
+export type ExportFormat = 'csv' | 'json';
+/** Schnittstelle der Komponente zur Fachlogik; Standardumsetzung: `createSamplingRestPort`. */
+export interface SamplingPort {
+    profiles(): Promise<SamplingCatalogue>;
+    size(request: SizeRequest): Promise<SizeResult>;
+    allocation(request: AllocationRequest): Promise<AllocationResult>;
+    selection(request: SelectionRequest): Promise<SelectionResult>;
+    exportSelection(request: SelectionRequest & {
+        seed: number;
+    }, format: ExportFormat): Promise<DownloadFile>;
+}

package/dist/sampling/view.d.ts

@@ -0,0 +1,45 @@
+import { TableColumn, TableRow } from '@auditcore/common';
+import { BadgeTone } from '../base/types';
+import { Locale, Translate } from '../i18n';
+import { SamplingMessageKey } from './messages';
+import { FieldError } from './model';
+import { ConfidenceLevel, MethodProfile, ParameterSpec, PopulationItem, SamplingCatalogue, SelectionResult, SizeResult } from './types';
+import { SelectionError } from './controller';
+export type SamplingTranslate = Translate<SamplingMessageKey>;
+/** Einheit hinter dem Eingabefeld (Prozent, Euro oder keine). */
+export declare function parameterUnit(spec: ParameterSpec): string;
+/** Fehlermeldung eines Eingabefelds, leer ohne Fehler. */
+export declare function samplingFieldError(error: FieldError | undefined, t: SamplingTranslate, locale: Locale): string;
+export declare function selectionErrorKey(error: SelectionError): SamplingMessageKey;
+export declare function confidenceText(level: ConfidenceLevel, t: SamplingTranslate, locale: Locale): string;
+export interface MethodGroup {
+    kind: 'mus' | 'srs';
+    label: string;
+    methods: MethodProfile[];
+}
+export declare function methodGroups(catalogue: SamplingCatalogue): MethodGroup[];
+export declare function methodTone(profile: MethodProfile | null): BadgeTone;
+export declare function methodStatusKey(profile: MethodProfile): SamplingMessageKey;
+/** Zusammenfassung der Grundgesamtheit; leer, wenn keine Elemente vorliegen. */
+export declare function populationText(items: readonly PopulationItem[], t: SamplingTranslate, locale: Locale): string;
+export declare function derivationColumns(t: SamplingTranslate, locale: Locale): TableColumn[];
+export declare function derivationRows(result: SizeResult): TableRow[];
+export declare function sizeTexts(result: SizeResult, t: SamplingTranslate, locale: Locale): {
+    size: string;
+    interval: string;
+};
+export declare function selectionColumns(result: SelectionResult, t: SamplingTranslate, locale: Locale): TableColumn[];
+export declare function strataColumns(result: SelectionResult, t: SamplingTranslate, locale: Locale): TableColumn[];
+export declare function strataRows(result: SelectionResult): TableRow[];
+export declare function selectionRows(result: SelectionResult): TableRow[];
+/** Hinweise auf Elemente außerhalb der Auswahlbasis. */
+export declare function excludedLines(result: SelectionResult, t: SamplingTranslate): string[];
+export interface SelectionTexts {
+    seed: string;
+    origin: string;
+    summary: string;
+    reproducible: string;
+}
+export declare function selectionTexts(result: SelectionResult, t: SamplingTranslate, locale: Locale): SelectionTexts;
+/** Zahlformat der Eingabefelder (ohne Tausendertrennung, bis 6 Nachkommastellen). */
+export declare function samplingInputNumber(locale: Locale): (value: number) => string;

package/dist/screening/controller.d.ts

@@ -0,0 +1,52 @@
+import { Store } from '../store';
+import { HitView, LogView, Outcome, RunRequest, RunSummary, RunView, ScreeningPort, SettingsView, SourcesView, SubjectView } from './types';
+import { HitFilter } from './view';
+/** Fehler einer Portanfrage: Meldung des Servers bzw. `network_error` mit Status 0. */
+export interface ScreeningError {
+    code: string;
+    message: string;
+    status: number;
+}
+export interface ReviewEvents {
+    onRunCreated?: (run: RunView) => void;
+    onDecided?: (payload: {
+        runId: string;
+        hitId: string;
+        status: string;
+    }) => void;
+    onError?: (error: ScreeningError) => void;
+    /** Meldung für Fehler ohne Serverantwort (Netz, Programmfehler). */
+    networkMessage?: (message: string) => string;
+}
+export interface ScreeningData {
+    settings: SettingsView | null;
+    sources: SourcesView | null;
+    runs: RunSummary[];
+    run: RunView | null;
+    log: LogView | null;
+    selectedHitId: string | null;
+    filter: HitFilter;
+    busy: boolean;
+    error: ScreeningError | null;
+}
+export interface ScreeningSelection {
+    visibleSubjects: SubjectView[];
+    selected: {
+        subject: SubjectView;
+        hit: HitView;
+    } | null;
+}
+export declare function selectScreening(state: ScreeningData): ScreeningSelection;
+export declare function asScreeningError(error: unknown, events: ReviewEvents): ScreeningError;
+export declare function createScreeningController(port: () => ScreeningPort | null | undefined, events?: () => ReviewEvents): {
+    select: (hitId: string | null) => void;
+    setFilter: (filter: HitFilter) => void;
+    selectNext(): void;
+    decide: (outcome: Outcome, reason: string, fourEyes: boolean) => Promise<boolean>;
+    secondReview: (approve: boolean, reason: string) => Promise<boolean>;
+    load: () => Promise<void>;
+    openRun: (runId: string) => Promise<void>;
+    createRun: (request: RunRequest) => Promise<boolean>;
+    store: Store<ScreeningData>;
+};
+export type ScreeningController = ReturnType<typeof createScreeningController>;

package/dist/screening/index.d.ts

@@ -0,0 +1,8 @@
+/** Kern der Screening-Trefferprüfung (Vertrag `screening_review/1`), gemeinsam für Vue und React. */
+export { codeLabel, screeningMessages, type ScreeningKey, type ScreeningTranslate } from './messages';
+export { createScreeningRestPort } from './rest-port';
+export type * from './types';
+export { CONTRACT as SCREENING_CONTRACT } from './types';
+export { acceptsHit, awaitsSecondReview, breakdownRows, canDecide, comparisonRows, emptyFilter, filterOptions, filterSubjects, findHit, formatAge, formatDate as formatScreeningDate, formatPoints, formatScore, freshnessTone, indicatorLabels, nextOpenHit, parseSubjects, replaceHit, requiresFourEyes, scorePercent, validateDecision, type BreakdownRow, type ComparisonRow, type DecisionForm as ScreeningDecisionForm, type FilterOptions, type HitFilter, type MatchState, type Tone as BreakdownTone, type ViewMessage, } from './view';
+export { asScreeningError, createScreeningController, selectScreening, type ReviewEvents, type ScreeningController, type ScreeningData, type ScreeningError, type ScreeningSelection, } from './controller';
+export { SCREENING_KINDS, buildRunRequest, kindProfiles, kindSources, profileKeyOf, runFormDefaults, selectedProfile, type RunForm as ScreeningRunFormState, } from './runForm';

package/dist/screening/messages.d.ts

@@ -0,0 +1,7 @@
+import { Translate } from '../i18n';
+/** Texte der Screening-Trefferprüfung (Sanktionslisten, PEP). */
+export declare const screeningMessages: import('..').Catalogs<"notice" | "unknown" | "input" | "title" | "entries" | "reason" | "profile" | "kind" | "method" | "noPort" | "networkError" | "complete" | "hints" | "decision" | "recommended" | "all" | "selectRun" | "sources" | "sourcesOfRun" | "newRun" | "runs" | "run" | "runDated" | "hits" | "comparison" | "breakdown" | "secondReview" | "log" | "filters" | "fourEyes" | "fourEyesPolicy" | "approve" | "reject" | "approved" | "rejected" | "listEntry" | "attribute" | "matchColumn" | "inconsistent" | "noSelection" | "final" | "saveDecision" | "secondReviewHint" | "lastDecision" | "fourEyesMarker" | "fourEyesMarkerPolicy" | "secondReviewDone" | "nextOpen" | "filterStatus" | "filterList" | "filterSubject" | "filterConfidence" | "filterMinScore" | "filterText" | "born" | "countryOf" | "normalized" | "queriedLists" | "findingSearched" | "findingNotSearched" | "noHitsFiltered" | "noHits" | "viaAlias" | "dobConflict" | "countryConflict" | "truncated" | "limitations" | "logEmpty" | "logSecondReview" | "logFourEyes" | "logSubjects" | "profileLine" | "namesHits" | "incompleteRun" | "lists" | "noStock" | "noStockRun" | "noStockHint" | "subjects" | "subjectsPlaceholder" | "minScore" | "caseReference" | "startRun" | "noRuns" | "runSummary" | "openCount" | "incompleteCount" | "level" | "minScoreBadge" | "classFrom" | "checkedAt" | "noSources" | "asOf" | "columnList" | "columnEntries" | "columnAsOf" | "via" | "dataLicence" | "ageUnknown" | "ageToday" | "ageOne" | "ageDays" | "asOfUnknown" | "rowName" | "rowMatched" | "rowAliases" | "rowBirth" | "rowCountry" | "rowAddress" | "rowIdentifiers" | "rowProgram" | "rowList" | "rowAsOf" | "stateMatch" | "stateConflict" | "stateNotCompared" | "errorOutcome" | "errorReason" | "errorReasonLength" | "errorLine" | "errorNoSubject" | "errorProfile" | "errorLists" | "status_open" | "status_pending_second_review" | "status_confirmed" | "status_dismissed" | "status_deferred" | "action_confirmed" | "action_dismissed" | "action_deferred" | "hint_confirmed" | "hint_dismissed" | "hint_deferred" | "subject_HITS" | "subject_NO_HITS" | "subject_INCOMPLETE" | "subject_NOT_SEARCHED" | "fresh_current" | "fresh_stale" | "fresh_unknown" | "fresh_not_judged" | "class_exact" | "class_high" | "class_medium" | "class_low" | "class_fuzzy" | "kind_sanctions" | "kind_pep" | "indicator_token_subset" | "indicator_alias_match" | "indicator_date_of_birth_not_compared" | "indicator_country_not_compared" | "indicator_below_min_score_after_adjustment">;
+export type ScreeningKey = keyof typeof screeningMessages.de;
+export type ScreeningTranslate = Translate<ScreeningKey>;
+/** Beschriftung eines Codes aus dem Vertrag (Status, Stufe, Hinweis); unbekannte Codes bleiben stehen. */
+export declare function codeLabel(t: ScreeningTranslate, prefix: string, code: string): string;

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

@@ -0,0 +1,4 @@
+import { RestOptions } from '@auditcore/common';
+import { ScreeningPort } from './types';
+/** Port auf den REST-Vertrag `screening_review/1` von `auditcore_registry_sources.web`. */
+export declare function createScreeningRestPort(options: RestOptions): ScreeningPort;

package/dist/screening/runForm.d.ts

@@ -0,0 +1,22 @@
+import { ProfileView, RunRequest, ScreeningKind, SettingsView, SourceView } from './types';
+import { ViewMessage } from './view';
+export declare const SCREENING_KINDS: readonly ScreeningKind[];
+export interface RunForm {
+    kind: ScreeningKind;
+    profileKey: string;
+    lists: string[];
+    subjectsText: string;
+    minScore: number | null;
+    caseReference: string;
+}
+export declare const profileKeyOf: (profile: Pick<ProfileView, "id" | "version">) => string;
+export declare function kindProfiles(settings: SettingsView, kind: ScreeningKind): ProfileView[];
+export declare function kindSources(sources: readonly SourceView[], kind: ScreeningKind): SourceView[];
+export declare function selectedProfile(settings: SettingsView, form: Pick<RunForm, 'kind' | 'profileKey'>): ProfileView | undefined;
+/** Vorbelegung bei Wechsel der Prüfart oder neuen Einstellungen: empfohlenes Profil, alle Listen, Standard-Mindestwert. */
+export declare function runFormDefaults(settings: SettingsView, sources: readonly SourceView[], kind: ScreeningKind): Pick<RunForm, 'profileKey' | 'lists' | 'minScore'>;
+/** Anfrage aus dem Formular; bei Fehlern `request: null` und die Meldungen als Katalogschlüssel. */
+export declare function buildRunRequest(settings: SettingsView, form: RunForm): {
+    request: RunRequest | null;
+    errors: ViewMessage[];
+};