@auditcore/ui-core 0.3.0

package/dist/extrapolation/types.d.ts

@@ -0,0 +1,255 @@
+import { DownloadFile } from '@auditcore/common';
+export interface ExtrapolationMethod {
+    id: string;
+    label: string;
+    statistical: boolean;
+    selection: 'equal_probability' | 'pps';
+    stratification: boolean;
+    source: string;
+    formula: string;
+    needs_population_size: boolean;
+    needs_sample_size: boolean;
+    /** Mehrperiodenform vorhanden (Leitfaden 7.3); fehlt bei älteren Backends. */
+    periods?: boolean;
+}
+export type ExtrapolationDesign = 'single' | 'periods' | 'groups';
+export interface SystemAssessmentLevel {
+    category: number;
+    label: string;
+    confidence_level: number;
+}
+export interface FactorProfileInfo {
+    id: string;
+    label: string;
+    source: string;
+    note: string;
+}
+export interface ExtrapolationCatalogue {
+    contract: string;
+    library: string;
+    sources: Readonly<Record<string, string>>;
+    methods: readonly ExtrapolationMethod[];
+    factor_profiles: readonly FactorProfileInfo[];
+    recommended_profile: string;
+    confidence_levels: {
+        z: readonly number[];
+        'mus.conservative': readonly number[];
+    };
+    materiality: {
+        default: number;
+        maximum: number;
+    };
+    error_classes: readonly {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+    conclusions: readonly {
+        id: Conclusion;
+        label: string;
+    }[];
+    limits: {
+        max_units: number;
+        max_strata: number;
+        max_periods?: number;
+    };
+    designs?: readonly {
+        id: ExtrapolationDesign;
+        label: string;
+        source: string;
+    }[];
+    subsample_estimators?: readonly {
+        id: SubsampleEstimator;
+        label: string;
+    }[];
+    system_assessment?: readonly SystemAssessmentLevel[];
+}
+export type SubsampleEstimator = 'ratio' | 'mean_per_unit' | 'pps';
+/** Teilstichprobe einer Einheit (Leitfaden 7.6, 6.5.3). */
+export interface SubsampleInput {
+    estimator: SubsampleEstimator;
+    strata: readonly StratumInput[];
+    units: readonly UnitInput[];
+}
+export interface StratumInput {
+    name: string;
+    book_value: number;
+    population_size?: number;
+    systemic_error?: number;
+    /** Zeitraum (mit `periods`) */
+    period?: string;
+    /** Programm einer Gruppe von Programmen (Leitfaden 7.8) */
+    group?: string;
+}
+export interface UnitInput {
+    id: string;
+    stratum: string;
+    book_value: number;
+    random_error?: number;
+    systemic_error?: number;
+    anomalous_error?: number;
+    anomalous_reason?: string;
+    anomalous_corrected?: boolean;
+    exhaustive?: boolean;
+    period?: string;
+    subsample?: SubsampleInput;
+}
+export interface EvaluationRequest {
+    method: string;
+    confidence_level?: number;
+    factor_profile?: string;
+    sample_size?: number;
+    materiality_rate: number;
+    strata: readonly StratumInput[];
+    units: readonly UnitInput[];
+    periods?: readonly {
+        name: string;
+    }[];
+    population_units?: number;
+    system_assessment?: number;
+}
+export interface ExtrapolationStep {
+    label: string;
+    formula: string;
+    value: number;
+    source: string;
+}
+export interface StratumProjection {
+    name: string;
+    projected_error: number;
+    exhaustive_error: number;
+    sample_size: number;
+    sampling_book_value: number;
+    figures: Readonly<Record<string, number>>;
+    period?: string;
+}
+export interface PeriodSummary {
+    name: string;
+    book_value: number;
+    projected_random_error: number;
+    precision: number | null;
+    sample_size: number;
+}
+export interface SubsampleResult {
+    unit_id: string;
+    estimator: SubsampleEstimator;
+    book_value: number;
+    projected_error: number;
+    error_rate: number;
+    audited_book_value: number;
+    coverage: number;
+    sampled_items: number;
+    exhaustive_items: number;
+    warnings: readonly string[];
+}
+export interface ConfidenceRecalculation {
+    applicable: boolean;
+    reason: string | null;
+    coefficient: number | null;
+    recalculated_coefficient: number | null;
+    confidence_level: number | null;
+    required_level: number | null;
+    supports_not_material: boolean | null;
+    steps: readonly ExtrapolationStep[];
+}
+export interface Projection {
+    method: string;
+    projected_random_error: number;
+    precision: number | null;
+    confidence_level: number | null;
+    factor_profile: string | null;
+    coefficient: number | null;
+    strata: readonly StratumProjection[];
+    sample_errors: {
+        random: number;
+        systemic: number;
+        anomalous_uncorrected: number;
+        anomalous_corrected: number;
+    };
+    systemic_population: number;
+    steps: readonly ExtrapolationStep[];
+    warnings: readonly string[];
+    extra: Readonly<Record<string, unknown>>;
+}
+export type Conclusion = 'material' | 'not_material' | 'inconclusive';
+export interface TotalErrorRate {
+    book_value: number;
+    materiality_rate: number;
+    tolerable_error: number;
+    projected_random_error: number;
+    systemic_errors: number;
+    anomalous_uncorrected: number;
+    anomalous_corrected_excluded: number;
+    total_error: number;
+    rate: number;
+    precision: number | null;
+    upper_limit: number | null;
+    upper_limit_rate: number | null;
+    conclusion: Conclusion;
+    explanation: readonly string[];
+    steps: readonly ExtrapolationStep[];
+    difference: {
+        corrected_book_value: number;
+        lower_limit: number;
+        book_value_less_tolerable: number;
+    } | null;
+}
+export interface EvaluationResult {
+    contract: string;
+    library: string;
+    fingerprint: string;
+    method: ExtrapolationMethod;
+    projection: Projection;
+    total_error_rate: TotalErrorRate;
+    design?: ExtrapolationDesign;
+    confidence_recalculation?: ConfidenceRecalculation;
+    subsamples?: readonly SubsampleResult[];
+    groups?: readonly GroupResult[];
+}
+export interface GroupResult {
+    name: string;
+    observations: number;
+    warnings: readonly string[];
+    projection: Projection;
+    total_error_rate: TotalErrorRate;
+}
+export interface ResidualRequest {
+    audit_population: number;
+    total_error_rate: number;
+    ongoing_assessment: number;
+    other_negative_amounts: number;
+    financial_corrections: number;
+    materiality_rate: number;
+}
+export interface ResidualRow {
+    row: string;
+    label: string;
+    value: number | null;
+    exact: string | null;
+}
+export interface ResidualErrorRate {
+    source: string;
+    rate: number | null;
+    rate_rounded: number | null;
+    exceeds_materiality: boolean;
+    materiality_rate: number;
+    extrapolated_correction: number | null;
+    rate_after_correction: number | null;
+    rows: readonly ResidualRow[];
+    not_applicable: string | null;
+    notes: readonly string[];
+}
+export interface ResidualResult {
+    contract: string;
+    library: string;
+    fingerprint: string;
+    residual_error_rate: ResidualErrorRate;
+}
+export type ExtrapolationExportFormat = 'csv' | 'json';
+/** Schnittstelle der Komponente zur Fachlogik; Standardumsetzung: `createExtrapolationRestPort`. */
+export interface ExtrapolationPort {
+    profiles(): Promise<ExtrapolationCatalogue>;
+    evaluate(request: EvaluationRequest): Promise<EvaluationResult>;
+    residual(request: ResidualRequest): Promise<ResidualResult>;
+    exportEvaluation(request: EvaluationRequest, format: ExtrapolationExportFormat): Promise<DownloadFile>;
+}

package/dist/extrapolation/view-details.d.ts

@@ -0,0 +1,46 @@
+import { TableColumn, TableRow } from '@auditcore/common';
+import { Locale } from '../i18n';
+import { openSubsample } from './controller-subsample';
+import { ExtrapolationData } from './controller';
+import { SubItemRow, SubStratumRow } from './model-subsample';
+import { ExtrapolationField, ExtrapolationMetric, ExtrapolationTranslate } from './view';
+import { EvaluationResult, ExtrapolationCatalogue, ExtrapolationDesign, SubsampleEstimator } from './types';
+export interface ExtrapolationChoice<T extends string> {
+    id: T;
+    label: string;
+}
+export declare function extrapolationDesignChoices(catalogue: ExtrapolationCatalogue | null, t: ExtrapolationTranslate): ExtrapolationChoice<ExtrapolationDesign>[];
+export declare function subsampleEstimatorChoices(t: ExtrapolationTranslate): ExtrapolationChoice<SubsampleEstimator>[];
+/** Kategorien 1–4 der Systembewertung mit Konfidenzniveau (Tabelle 1, Leitfaden 3.2.1). */
+export declare function systemAssessmentChoices(catalogue: ExtrapolationCatalogue | null, locale: Locale): ExtrapolationChoice<string>[];
+export declare const SUB_ITEM_FIELDS: readonly ExtrapolationField<'id' | 'bookValue' | 'random'>[];
+export declare const SUB_STRATUM_FIELDS: readonly ExtrapolationField<'name' | 'bookValue' | 'populationSize'>[];
+export type SubStratumFieldKey = keyof Pick<SubStratumRow, 'name' | 'bookValue' | 'populationSize'>;
+/** Ansicht der gerade bearbeiteten Teilstichprobe: Zeilen, Überschrift, Feldpräfix, Stufe. */
+export interface SubsampleEditorView {
+    rows: NonNullable<ReturnType<typeof openSubsample>>;
+    title: string;
+    /** Präfix der Feldbefunde, z. B. `units.2.subsample`. */
+    prefix: string;
+    nested: boolean;
+    /** Teileinheiten dürfen eine eigene Teilstichprobe haben (nur Stufe 2). */
+    allowNested: boolean;
+}
+export declare function subsampleEditorView(state: ExtrapolationData, t: ExtrapolationTranslate): SubsampleEditorView | null;
+export type SubItemFieldKey = keyof Pick<SubItemRow, 'id' | 'bookValue' | 'random'>;
+export declare function periodColumns(t: ExtrapolationTranslate, locale: Locale): TableColumn[];
+export declare function periodRows(result: EvaluationResult): TableRow[];
+export declare function groupColumns(t: ExtrapolationTranslate, locale: Locale): TableColumn[];
+export declare function groupRows(result: EvaluationResult, catalogue: ExtrapolationCatalogue | null): TableRow[];
+export declare function subsampleColumns(t: ExtrapolationTranslate, locale: Locale): TableColumn[];
+export declare function subsampleResultRows(result: EvaluationResult, t: ExtrapolationTranslate): TableRow[];
+/** Hinweise aus Gruppen und Teilstichproben (die der Hochrechnung stehen im Ergebnis). */
+export declare function detailWarnings(result: EvaluationResult): string[];
+export interface RecalculationView {
+    metrics: ExtrapolationMetric[];
+    verdict: string;
+}
+/** Neuberechnung des Konfidenzniveaus; `null`, wenn nicht anwendbar (Ergebnis schlüssig usw.). */
+export declare function recalculationView(result: EvaluationResult, t: ExtrapolationTranslate, locale: Locale): RecalculationView | null;
+/** Gibt es Ergänzungen anzuzeigen? */
+export declare function hasExtrapolationDetails(result: EvaluationResult): boolean;

package/dist/extrapolation/view.d.ts

@@ -0,0 +1,50 @@
+import { TableColumn, TableRow } from '@auditcore/common';
+import { BadgeTone } from '../base/types';
+import { Locale, Translate } from '../i18n';
+import { ExtrapolationMessageKey } from './messages';
+import { ExtrapolationFormError, ExtrapolationIssue } from './model';
+import { Conclusion, EvaluationResult, ExtrapolationCatalogue, ExtrapolationMethod, ResidualErrorRate } from './types';
+export type ExtrapolationTranslate = Translate<ExtrapolationMessageKey>;
+export declare function conclusionTone(conclusion: Conclusion): BadgeTone;
+export declare function conclusionLabel(catalogue: ExtrapolationCatalogue | null, conclusion: Conclusion): string;
+export declare function extrapolationAmount(value: number, locale: Locale): string;
+export declare function extrapolationRate(value: number, locale: Locale): string;
+/** Zahl als Eingabetext (ohne Tausendertrenner). */
+export declare function extrapolationInputNumber(locale: Locale): (value: number) => string;
+export declare function extrapolationIssueKey(issue: ExtrapolationIssue): ExtrapolationMessageKey;
+export declare function extrapolationFormErrorKey(error: ExtrapolationFormError): ExtrapolationMessageKey;
+export interface ExtrapolationMethodGroup {
+    statistical: boolean;
+    label: string;
+    methods: readonly ExtrapolationMethod[];
+}
+export declare function extrapolationMethodGroups(catalogue: ExtrapolationCatalogue, t: ExtrapolationTranslate): ExtrapolationMethodGroup[];
+export declare function extrapolationConfidenceLabel(level: number, locale: Locale): string;
+export interface ExtrapolationMetric {
+    id: string;
+    label: string;
+    value: string;
+    detail?: string;
+}
+/** Kennzahlen der Gesamtfehlerquote in fester Reihenfolge. */
+export declare function terMetrics(result: EvaluationResult, t: ExtrapolationTranslate, locale: Locale): ExtrapolationMetric[];
+export declare function extrapolationStepColumns(t: ExtrapolationTranslate, locale: Locale): TableColumn[];
+export declare function extrapolationStepRows(result: EvaluationResult): TableRow[];
+export declare function residualColumns(t: ExtrapolationTranslate, locale: Locale): TableColumn[];
+export declare function residualRows(residual: ResidualErrorRate): TableRow[];
+/** Kennzahlen der Restfehlerquote (K, L, M). */
+export declare function residualMetrics(residual: ResidualErrorRate, t: ExtrapolationTranslate, locale: Locale): ExtrapolationMetric[];
+export interface ExtrapolationField<K extends string> {
+    key: K;
+    label: ExtrapolationMessageKey;
+    numeric: boolean;
+}
+export declare const STRATUM_FIELDS: readonly ExtrapolationField<'name' | 'bookValue' | 'populationSize' | 'systemic'>[];
+export declare const UNIT_FIELDS: readonly ExtrapolationField<'id' | 'bookValue' | 'random' | 'systemic' | 'anomalous' | 'reason'>[];
+export declare const UNIT_FLAGS: readonly ExtrapolationField<'corrected' | 'exhaustive'>[];
+export declare const RESIDUAL_FIELDS: readonly ExtrapolationField<'auditPopulation' | 'terRate' | 'ongoing' | 'otherNegative' | 'corrections'>[];
+/** Meldung eines Feldes (leer ohne Befund). */
+export declare function extrapolationIssueText(issues: Readonly<Record<string, ExtrapolationIssue>>, key: string, t: ExtrapolationTranslate): string;
+/** Sammelmeldung unter dem Formular: fehlende Auswahl oder markierte Felder. */
+export declare function extrapolationFormMessage(formError: ExtrapolationFormError | null, issues: Readonly<Record<string, ExtrapolationIssue>>, t: ExtrapolationTranslate): string;
+export declare function extrapolationCellLabel(t: ExtrapolationTranslate, field: ExtrapolationMessageKey, row: number): string;

package/dist/focus.d.ts

@@ -0,0 +1,10 @@
+export declare function focusableWithin(container: HTMLElement): HTMLElement[];
+/** Nächstes Fokusziel beim Tabben am Rand des Containers, sonst null (Browser übernimmt). */
+export declare function wrapTarget(items: HTMLElement[], current: Element | null, backwards: boolean): HTMLElement | null;
+export interface FocusTrap {
+    /** Fokus in den Container (Element mit `autofocus`, sonst erstes fokussierbares) und Tab-Taste einfangen. */
+    activate: () => void;
+    /** Falle lösen und den Fokus an das vorher fokussierte Element zurückgeben. */
+    deactivate: () => void;
+}
+export declare function createFocusTrap(container: () => HTMLElement | null): FocusTrap;

package/dist/geo/controller.d.ts

@@ -0,0 +1,87 @@
+import { Store } from '../store';
+import { CoordinateError, UtmInputError } from './model';
+import { MapLayers } from './mapView';
+import { GeoArea, GeoCatalogue, GeocodeResult, GeoPackageResult, GeoPoint, GeoPort, LatLon, LocateResult, RadiusResult, SimplifyResult, SimplifyUnit, UtmResult } from './types';
+export type GeoBusy = 'load' | 'radius' | 'locate' | 'utm' | 'simplify' | 'gpkg' | 'geocode';
+export type GeoHint = 'needReference' | 'needArea' | 'needModel' | null;
+export interface GeoMapCallbacks {
+    radius?: (result: RadiusResult) => void;
+    located?: (result: LocateResult) => void;
+    areasLoaded?: (areas: readonly GeoArea[], result: GeoPackageResult) => void;
+    reference?: (point: LatLon | null) => void;
+    failed?: (message: string) => void;
+}
+export interface GeoData {
+    busy: GeoBusy | null;
+    failure: string;
+    error: string | null;
+    notice: string;
+    hint: GeoHint;
+    catalogue: GeoCatalogue | null;
+    earthModel: string | null;
+    radiusMetres: number;
+    radiusResult: RadiusResult | null;
+    boundaryInside: boolean;
+    toleranceMetres: number;
+    locateResult: LocateResult | null;
+    loadedAreas: readonly GeoArea[];
+    areaId: string | null;
+    simplifyUnit: SimplifyUnit;
+    simplifyStep: number;
+    simplifyResult: SimplifyResult | null;
+    gpkgResult: GeoPackageResult | null;
+    ellipsoid: string;
+    reference: LatLon | null;
+    latText: string;
+    lonText: string;
+    coordinateError: CoordinateError;
+    utm: UtmResult | null;
+    /** Eingabefelder der UTM-Rückrechnung (`POST /utm/geographisch`). */
+    zoneText: string;
+    eastText: string;
+    northText: string;
+    northern: boolean;
+    utmError: UtmInputError;
+    geocodeResult: GeocodeResult | null;
+}
+/** Eingaben der Komponente (Props). */
+export interface GeoInputs {
+    port: GeoPort | null;
+    points: readonly GeoPoint[];
+    areas: readonly GeoArea[];
+}
+export interface GeoSelection {
+    areas: readonly GeoArea[];
+    area: GeoArea | null;
+    simplifyTolerance: number;
+    hitIds: ReadonlySet<string>;
+    canGeocode: boolean;
+    /** Port bietet die Rückrechnung aus UTM an. */
+    canFromUtm: boolean;
+    layers: MapLayers;
+}
+export declare function selectGeo(state: GeoData, inputs: GeoInputs): GeoSelection;
+/** Einfache Eingabefelder, die die Oberfläche direkt setzen darf. */
+export type GeoField = 'radiusMetres' | 'earthModel' | 'boundaryInside' | 'toleranceMetres' | 'simplifyStep' | 'ellipsoid' | 'latText' | 'lonText' | 'zoneText' | 'eastText' | 'northText' | 'northern';
+export interface GeoControllerOptions extends GeoMapCallbacks {
+    inputs: () => GeoInputs;
+}
+export declare function createGeoController(options: GeoControllerOptions): {
+    simplifyArea: () => Promise<void>;
+    selectArea: (id: string | null) => void;
+    setSimplifyUnit: (unit: SimplifyUnit) => void;
+    loadFile: (file: Blob) => Promise<void>;
+    loadSource: (name: string) => Promise<void>;
+    applyUtm: () => Promise<void>;
+    refreshUtm: () => Promise<void>;
+    setReference: (point: LatLon | null) => Promise<void>;
+    applyTexts: () => Promise<void>;
+    geocode: (query: string) => Promise<void>;
+    load: () => Promise<void>;
+    searchRadius: () => Promise<void>;
+    checkLocation: () => Promise<void>;
+    store: Store<GeoData>;
+    /** Einfaches Eingabefeld setzen (Radius, Erdmodell, Rand, Toleranz, Stufe, Ellipsoid, Texte). */
+    setField: <K extends GeoField>(key: K, value: GeoData[K]) => void;
+};
+export type GeoController = ReturnType<typeof createGeoController>;

package/dist/geo/index.d.ts

@@ -0,0 +1,6 @@
+export { geoMessages, type GeoMessageKey } from './messages';
+export * from './model';
+export { createGeoRestPort, type GeoRestOptions } from './rest-port';
+export type * from './types';
+export { createLeafletView, escapeHtml as escapeMapHtml, type MapLayers, type MapView, type MapViewOptions } from './mapView';
+export * from './controller';

package/dist/geo/mapView.d.ts

@@ -0,0 +1,30 @@
+import { AreaGeometry, GeoArea, GeoPoint, LatLon, TileSource } from './types';
+export interface MapLayers {
+    points: readonly GeoPoint[];
+    areas: readonly GeoArea[];
+    reference: LatLon | null;
+    radiusMetres: number | null;
+    hits: ReadonlySet<string>;
+    selectedArea: string | null;
+    simplified: AreaGeometry | null;
+}
+export interface MapViewOptions {
+    center: LatLon;
+    zoom: number;
+    tiles: TileSource | null;
+    /** Klick auf die Karte: neuer Bezugspunkt. */
+    onPick: (point: LatLon) => void;
+    /** Beschriftung eines Punktes bzw. einer Fläche für Tooltips. */
+    label: (entry: GeoPoint | GeoArea) => string;
+}
+export interface MapView {
+    update(layers: MapLayers): void;
+    setTiles(tiles: TileSource | null): void;
+    /** Ausschnitt auf alle Punkte, Flächen und den Umkreis setzen. */
+    fit(): void;
+    destroy(): void;
+}
+/** Leaflet setzt Tooltips und Namensnennung als HTML; Daten gehen deshalb nur als Text hinein. */
+export declare function escapeHtml(text: string): string;
+/** Legt die Leaflet-Karte im Element an. */
+export declare function createLeafletView(element: HTMLElement, options: MapViewOptions): Promise<MapView>;

package/dist/geo/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte der Geo-Karte. */
+export declare const geoMessages: import('..').Catalogs<"loading" | "apply" | "area" | "title" | "unit" | "noPort" | "failed" | "mapLabel" | "noTiles" | "attribution" | "fit" | "reference" | "referenceHelp" | "lat" | "lon" | "fromPoint" | "choose" | "errorlat" | "errorlon" | "utm" | "utmValue" | "utmEpsg" | "utmNote" | "ellipsoid" | "utmInput" | "utmInputHelp" | "utmZone" | "utmHemisphere" | "hemisphereNorth" | "hemisphereSouth" | "utmEast" | "utmNorth" | "utmerrorzone" | "utmerroreast" | "utmerrornorth" | "geocode" | "geocodeHelp" | "geocodeRun" | "geocodeNone" | "radius" | "radiusMetres" | "earthModel" | "recommended" | "radiusRun" | "radiusSummary" | "colName" | "colDistance" | "locate" | "boundaryInside" | "boundaryHelp" | "tolerance" | "locateRun" | "positioninnen" | "positionaussen" | "positionrand" | "contains" | "notContains" | "boundaryCase" | "boundaryExact" | "boundaryTolerance" | "ruleInside" | "ruleOutside" | "distance" | "notes" | "simplify" | "unitmeter" | "unitgrad" | "simplifyTolerance" | "simplifyVertices" | "simplifyRun" | "simplifyResult" | "simplifyDropped" | "simplifyGone" | "gpkg" | "gpkgFile" | "gpkgSource" | "gpkgLoad" | "gpkgResult" | "gpkgConverted" | "gpkgTruncated" | "gpkgErrors" | "needReference" | "needArea" | "needModel">;
+export type GeoMessageKey = keyof typeof geoMessages.de;

package/dist/geo/model.d.ts

@@ -0,0 +1,43 @@
+import { Locale } from '../i18n';
+import { GeoMessageKey } from './messages';
+import { AreaGeometry, GeoArea, GeoPackageResult, GeoPoint, LatLon } from './types';
+/** Stufen des Toleranzreglers der Vereinfachung (Meter bzw. Grad). */
+export declare const TOLERANCE_STEPS: Readonly<Record<'meter' | 'grad', readonly number[]>>;
+/**
+ * Dezimalgrad aus Texteingabe; Komma und Punkt sind als Dezimaltrenner
+ * erlaubt, Tausendertrennzeichen nicht. Ungültiges ergibt `null`.
+ */
+export declare function parseDegrees(text: string): number | null;
+export type CoordinateError = 'lat' | 'lon' | null;
+/** Punkt aus zwei Texteingaben mit Wertebereichsprüfung. */
+export declare function parseLatLon(lat: string, lon: string): {
+    point: LatLon | null;
+    error: CoordinateError;
+};
+/** Meter aus Texteingabe (Komma oder Punkt, keine Tausendertrennung); Ungültiges ergibt `null`. */
+export declare function parseMetres(text: string): number | null;
+export type UtmInputError = 'zone' | 'east' | 'north' | null;
+export interface UtmInput {
+    zone: number;
+    ost: number;
+    nord: number;
+}
+/** UTM-Eingabe mit Wertebereichsprüfung: Zone 1–60, Ostwert 0–1 000 000 m, Nordwert 0–10 000 000 m. */
+export declare function parseUtm(zone: string, east: string, north: string): {
+    value: UtmInput | null;
+    error: UtmInputError;
+};
+/** Text der Fehlermeldung einer UTM-Eingabe. */
+export declare function utmErrorKey(error: Exclude<UtmInputError, null>): GeoMessageKey;
+/** Entfernung sprachabhängig: unter 1 km in Metern, sonst in Kilometern mit zwei Stellen. */
+export declare function formatDistance(metres: number, locale: Locale): string;
+/** Grad mit sechs Nachkommastellen (≈ 0,1 m). */
+export declare function formatDegrees(value: number, locale: Locale): string;
+/** Rechts-/Hochwert in Metern mit zwei Nachkommastellen, ohne Tausendertrennung. */
+export declare function formatMetres(value: number, locale: Locale): string;
+/** Anzahl der Stützpunkte einer Fläche (Schlusspunkte mitgezählt). */
+export declare function vertexCount(geometry: AreaGeometry): number;
+/** Flächen aus einer GeoPackage-Antwort; Kennungen erhalten die Herkunft als Präfix. */
+export declare function areasFromGeoPackage(result: GeoPackageResult, origin: string): GeoArea[];
+/** Bezeichnung für Listen: Name, sonst Kennung. */
+export declare function displayName(entry: GeoPoint | GeoArea): string;

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

@@ -0,0 +1,12 @@
+import { RestOptions } from '@auditcore/common';
+import { GeoPort } from './types';
+export interface GeoRestOptions extends RestOptions {
+    /**
+     * Adresssuche über `POST /geocode` anbieten. Standard `false`: ohne
+     * ausdrückliche Freigabe sendet die Oberfläche keine Adressen, auch wenn
+     * der Server einen Geocoder angeschlossen hat.
+     */
+    geocoding?: boolean;
+}
+/** Port auf den REST-Vertrag von `auditcore_geo.web` (Starlette oder FastAPI). */
+export declare function createGeoRestPort(options: GeoRestOptions): GeoPort;