@agridea/suibi-module 0.1.0-preview.01100f9

package/dist/types/app/core/navigation/navigation.service.d.ts

@@ -0,0 +1,100 @@
+export type PageId = 'welcome' | 'animal_stock' | 'data_preview' | 'storage' | 'field_spreading' | 'farm_manure_trading' | 'fodder' | 'field_cultivation' | 'validation' | 'results';
+export type AnimalStockCategory = 'base' | 'formOfDetention' | 'feeding';
+export type FarmManureTradingMode = 'supply' | 'dispense';
+export type FarmManureTradingCategory = 'general' | 'derivation' | 'ingredients';
+export type FodderMode = 'supply' | 'dispense' | 'non_fodder_cropland';
+export type FodderCategory = 'general' | 'ingredients';
+export type FieldSpreadingCategory = 'general' | 'fertiliser' | 'recycling';
+export type FieldCultivationTab = 'general' | 'fodderCropland' | 'arableLand' | 'special';
+export type StorageTab = 'manure' | 'slurry';
+export type StorageEntryType = 'manure_pit' | 'slurry_tank';
+/**
+ * NavigationService
+ * Global reactive store for application routing and deep-link state.
+ * Follows Pinia/Vuex pattern: signals = state, computed = getters, methods = actions.
+ *
+ * Responsibilities:
+ * - Track current page and page-specific context (e.g., selected entity index, active tab)
+ * - Provide navigation actions that update state atomically
+ * - Used by validation system to deep-link users to fields requiring correction
+ *
+ * Pattern for adding new pages:
+ * 1. Add page ID to PageId type
+ * 2. Add page-specific state signals (e.g., selectedStorageIndex)
+ * 3. Add navigation actions (e.g., navigateToStorageDetail)
+ * 4. Update reset logic in resetPageContext()
+ */
+export declare class NavigationService {
+    /** Current active page */
+    readonly currentPage: import("@angular/core").WritableSignal<PageId>;
+    /** Selected animal stock entry index (null = list view) */
+    readonly selectedAnimalStockIndex: import("@angular/core").WritableSignal<number | null>;
+    /**
+     * Generic category (tab) selection: stores current page + selected category key.
+     * Used by categorization renderer for programmatic tab control.
+     * Format: { page: PageId, category: string }
+     */
+    readonly selectedCategory: import("@angular/core").WritableSignal<{
+        page: PageId;
+        category: string;
+    }>;
+    /** Selected farm manure trading detail context (mode + index) */
+    readonly selectedFarmManureTrading: import("@angular/core").WritableSignal<{
+        mode: FarmManureTradingMode;
+        index: number;
+    } | null>;
+    /** Selected fodder detail context (mode + index) */
+    readonly selectedFodderDetail: import("@angular/core").WritableSignal<{
+        mode: FodderMode;
+        index: number;
+    } | null>;
+    /** Selected field cultivation detail context (tab + index) */
+    readonly selectedFieldCultivationDetail: import("@angular/core").WritableSignal<{
+        tab: Exclude<FieldCultivationTab, "general">;
+        index: number;
+    } | null>;
+    /** Selected storage detail context (type + index) */
+    readonly selectedStorageDetail: import("@angular/core").WritableSignal<{
+        type: StorageEntryType;
+        index: number;
+    } | null>;
+    /** True if currently viewing animal stock detail (not list) */
+    readonly isAnimalStockDetailView: import("@angular/core").Signal<boolean>;
+    /** True if currently on animal stock page (list or detail) */
+    readonly isAnimalStockPage: import("@angular/core").Signal<boolean>;
+    /**
+     * Navigate to a top-level page. Resets page-specific context.
+     * Use this for simple page switches (e.g., nav menu clicks).
+     */
+    navigateToPage(page: PageId): void;
+    /**
+     * Navigate to animal stock list view (no entry selected).
+     */
+    navigateToAnimalStockList(): void;
+    /**
+     * Navigate to animal stock detail view (specific entry + optional tab).
+     * Used by validation error navigation and internal routing.
+     */
+    navigateToAnimalStockDetail(index: number, category?: AnimalStockCategory): void;
+    navigateToFarmManureTradingDetail(mode: FarmManureTradingMode, index: number, category?: FarmManureTradingCategory): void;
+    navigateToFarmManureTradingList(): void;
+    navigateToFodderDetail(mode: FodderMode, index: number, category?: FodderCategory): void;
+    navigateToFodderList(): void;
+    navigateToFieldSpreading(category?: FieldSpreadingCategory): void;
+    navigateToFieldCultivationDetail(tab: Exclude<FieldCultivationTab, 'general'>, index: number): void;
+    navigateToFieldCultivationList(tab?: FieldCultivationTab): void;
+    navigateToStorageDetail(type: StorageEntryType, index: number): void;
+    navigateToStorageList(tab?: StorageTab): void;
+    /**
+     * Set active category/tab for current page (without changing page/entry).
+     * Generic method supporting any page's categorization navigation.
+     * No-op when page and category are already the same values to prevent
+     * unnecessary signal emissions that re-trigger the tab index computed.
+     */
+    setCategory(page: PageId, category: string): void;
+    /**
+     * Reset page-specific context when navigating away.
+     * Prevents stale state (e.g., old selected index) from affecting new page.
+     */
+    private resetPageContext;
+}

package/dist/types/app/core/planning/planning-balance.service.d.ts

@@ -0,0 +1,38 @@
+import { NaebiData } from '../data/naebi-data.service';
+import type { PlanningBalanceResponse } from './planning-balance.types';
+export type { PlanningBalanceResponse } from './planning-balance.types';
+/** Which backend to target for planning requests. */
+export type PlanningEndpoint = 'ebilanz' | 'blw';
+/**
+ * Sends NAEBI data to a planning endpoint and exposes the result as a
+ * signal-based resource. Call `runPlanning(data, endpoint)` to trigger a request.
+ *
+ * The ID counter ensures each call re-fetches even if the payload hasn't changed.
+ */
+export declare class PlanningBalanceService {
+    private readonly http;
+    private readonly metadataSvc;
+    private readonly _value;
+    private readonly _error;
+    private readonly _isLoading;
+    private readonly _selectedEndpoint;
+    private readonly _lastStartedRequestId;
+    private readonly _lastCompletedRequestId;
+    private readonly _lastSuccessfulRequestId;
+    private _nextId;
+    private activeRequestId;
+    private activeRequestSub;
+    readonly planningResource: {
+        value: import("@angular/core").Signal<PlanningBalanceResponse | undefined>;
+        error: import("@angular/core").Signal<unknown>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        hasValue: import("@angular/core").Signal<boolean>;
+        lastStartedRequestId: import("@angular/core").Signal<number>;
+        lastCompletedRequestId: import("@angular/core").Signal<number>;
+        lastSuccessfulRequestId: import("@angular/core").Signal<number>;
+    };
+    readonly selectedEndpoint: import("@angular/core").Signal<PlanningEndpoint>;
+    setSelectedEndpoint(endpoint: PlanningEndpoint): void;
+    /** Fire a new planning-balance request with the current NAEBI data payload. */
+    runPlanning(data: NaebiData, endpoint?: PlanningEndpoint): void;
+}

package/dist/types/app/core/planning/planning-balance.types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * TypeScript interfaces for the planning-balance API response.
+ * These match the eBilanz / BLW response shape observed in the example data.
+ */
+/** A single nutrient quantity entry (kg or % unit). */
+export interface NutrientEntry {
+    molecularFormula: string;
+    quantity: number;
+    quantityCorrected?: number;
+    unit: string;
+    productFamilyType?: string;
+    typeOfManureRecyclingProduct?: string;
+    fertiliserProductCategory?: string;
+}
+export interface CalculationVersion {
+    version: string;
+    validFrom: string;
+    validTo: string;
+}
+export interface AreaAndYieldPerAgronomicCropCategory {
+    agronomicCropCategory: string;
+    areaSize: number;
+    effectiveYield: number;
+    isMainCrop: boolean;
+    isNutrientPoorFodder: boolean;
+    yieldPerSquareMeasure?: number;
+}
+export interface AreaPerCultivationType {
+    areaSize: number;
+    isMainCrop: boolean;
+}
+export interface AreaAndYieldPerCultivationCategory {
+    cultivationCategory: string;
+    areaAndYieldPerAgronomicCropCategory: AreaAndYieldPerAgronomicCropCategory[];
+    areaPerCultivationType: AreaPerCultivationType[];
+}
+export interface AreaPerSubCategory {
+    cultivationSubCategory: string;
+    areaSize: number;
+    isMainCrop: boolean;
+}
+export interface FieldCultivation {
+    areaAndYieldPerCultivationCategory: AreaAndYieldPerCultivationCategory[];
+    areaPerSubCategory: AreaPerSubCategory[];
+    fertilizableAreaSize: number;
+    slurrySpreadingAreaSize: number;
+    totalAgriculturalLandAreaSize: number;
+}
+export interface FodderQuantity {
+    quantity: number;
+    unit: string;
+    proportionNutrientPoorFodder?: number;
+}
+export interface FodderProduct {
+    typeOfFeedstuffProduct: string;
+    quantity: number;
+    unit: string;
+    isNutrientPoorFodder: boolean;
+}
+export interface ConsumptionAnimalStock {
+    animalCategoryPRIF: number;
+    averageQuantity: number;
+    order: string;
+    quantity: number;
+    unit: string;
+}
+export interface RequiredEffectiveYieldFromFodderCropland {
+    consumptionAnimalStock: ConsumptionAnimalStock[];
+    cropFromNonFodderCroplandPerProduct: FodderProduct[];
+    dispensePerProduct: FodderProduct[];
+    supplyPerProduct: FodderProduct[];
+    totalBalance: FodderQuantity;
+    totalConsumptionAnimalStock: FodderQuantity;
+    totalCropFromNonFodderCropland: FodderQuantity;
+    totalDispense: FodderQuantity;
+    totalSupply: FodderQuantity;
+}
+export interface FodderBalance {
+    requiredEffectiveYieldFromFodderCropland: RequiredEffectiveYieldFromFodderCropland;
+    totalBalance: FodderQuantity;
+    totalEffectiveYieldFromFodderCropland: FodderQuantity;
+    totalNutrientPoorFodder: FodderQuantity;
+}
+export interface EmissionAndAccumulationEntry {
+    animalCategoryPRIF: number;
+    order: string;
+    accumulation: NutrientEntry[];
+    emission: NutrientEntry[];
+    manureExcretion?: unknown[];
+}
+export interface AccumulationEntireExcretion {
+    animalCategoryPRIF: number;
+    order: string;
+    durationSumTotalCorrectedNutrientBalance: number;
+    accumulation: NutrientEntry[];
+}
+export interface TotalNutrientSet {
+    accumulation: NutrientEntry[];
+    emission?: NutrientEntry[];
+}
+export interface AnimalStock {
+    accumulationEntireExcretion: AccumulationEntireExcretion[];
+    emissionAndAccumulationPasture: EmissionAndAccumulationEntry[];
+    emissionAndAccumulationStall: EmissionAndAccumulationEntry[];
+    emissionAndAccumulationYard: EmissionAndAccumulationEntry[];
+    totalAccumulationEntireExcretion: TotalNutrientSet;
+    totalEmissionAndAccumulationAnimalStock: TotalNutrientSet;
+    totalEmissionAndAccumulationPasture: TotalNutrientSet;
+    totalEmissionAndAccumulationStall: TotalNutrientSet;
+    totalEmissionAndAccumulationYard: TotalNutrientSet;
+}
+export interface ManureTradingProduct {
+    typeOfManureRecyclingProduct: string;
+    quantity: number;
+    unit: string;
+    ingredient: NutrientEntry[];
+}
+export interface FarmManureTrading {
+    balancePerProduct: ManureTradingProduct[];
+    dispensePerProduct: ManureTradingProduct[];
+    supplyPerProduct: ManureTradingProduct[];
+    totalBalance: {
+        ingredient: NutrientEntry[];
+    };
+}
+export interface NutrientRequirementEntry {
+    agronomicCropCategory?: string;
+    cultivationCategory?: string;
+    isMainCrop?: boolean;
+    requirement: NutrientEntry[];
+}
+export interface FieldCultivationNutrients {
+    nutrientTransferUnfertilizedCultivation: NutrientEntry[];
+    requirementPerAgronomicCropCategory: NutrientRequirementEntry[];
+    requirementPerCultivationCategory: NutrientRequirementEntry[];
+    totalRequirement: NutrientEntry[];
+}
+export interface FieldSpreading {
+    emissionAndAccumulationFieldSpreading: TotalNutrientSet;
+    totalEmissionAndAccumulationFieldSpreading: TotalNutrientSet;
+}
+export interface StorageBalance {
+    emissionAndAccumulationManureStorage: TotalNutrientSet;
+    totalEmissionAndAccumulationManureStorage: TotalNutrientSet;
+}
+export interface NutrientBalance {
+    animalStock: AnimalStock;
+    farmManureTrading: FarmManureTrading;
+    fieldCultivation: FieldCultivationNutrients;
+    fieldSpreading: FieldSpreading;
+    storage: StorageBalance;
+    /** Final per-nutrient balance figures: kg lines + % lines interleaved. */
+    totalBalance: NutrientEntry[];
+    /** Farm-wide gas emissions (NH3, NO, N2O, N2). */
+    totalEmissionFarm: NutrientEntry[];
+    nutrientBalanceTMP?: unknown[];
+}
+export interface NutrientCycle {
+    creationDateTime: string;
+    facilitySpecificProducts: {
+        manureRecyclingProduct: unknown[];
+    };
+    fieldCultivation: FieldCultivation;
+    fodderBalance: FodderBalance;
+    nutrientBalance: NutrientBalance;
+    version: string;
+    /** Base64-encoded PDF report, if returned by the endpoint. */
+    report?: string;
+}
+export interface ValidationMessageDetail {
+    designation_deu: string;
+    designation_eng: string;
+    designation_fra: string;
+    designation_ita: string;
+}
+export interface ValidationMessage {
+    field: string;
+    type: string;
+    detail: ValidationMessageDetail;
+}
+/** Full response from the planning-balance endpoint. */
+export interface PlanningBalanceResponse {
+    calculationVersion: CalculationVersion;
+    nutrientCycle: NutrientCycle;
+    validationMessage: ValidationMessage[];
+}
+/** Merged kg + % row for the final balance table (Section D). */
+export interface BalanceRow {
+    molecularFormula: string;
+    quantity: number;
+    quantityCorrected: number;
+    quantityPct: number | null;
+    quantityCorrectedPct: number | null;
+    unit: 'kg';
+}
+/** Crop requirement row enriched with area and yield for display (Section C). */
+export interface CropRequirementRow {
+    cropCode: string;
+    cultivationCategory: string;
+    isMainCrop: boolean;
+    areaHa: number;
+    effectiveYield: number;
+    /** kg/ha yield per square measure field (m² basis), converted to dt/ha for display. */
+    yieldDtHa: number | null;
+    requirement: NutrientEntry[];
+}

package/dist/types/app/core/planning/planning-balance.utils.d.ts

@@ -0,0 +1,10 @@
+import type { BalanceRow, NutrientEntry } from './planning-balance.types';
+/**
+ * Merges the interleaved kg / % rows from `totalBalance` into one `BalanceRow`
+ * per nutrient formula, preserving the canonical KEY_NUTRIENTS display order.
+ *
+ * The planning-balance API returns two `NutrientEntry` objects per formula
+ * (one with `unit === 'kg'`, one with `unit === '%'`). This function coalesces
+ * them so callers work with a single, normalised row.
+ */
+export declare function mergeBalanceRows(totalBalance: NutrientEntry[]): BalanceRow[];

package/dist/types/app/core/schemas/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Schema utilities for managing UI-only helper fields in JSONForms components.
+ *
+ * This module provides centralized schema merging and helper field filtering to maintain
+ * clean separation between domain schemas (nutrient balance calculation model) and
+ * UI-only helper fields that drive conditional rendering logic.
+ *
+ * @example
+ * ```typescript
+ * import { mergeSchemas, getUiHelperFields, stripUiHelpers } from '@core/schemas';
+ * import globalUiExtensions from '@core/schemas/ui-schema-extensions.json';
+ *
+ * const helpers = getUiHelperFields(globalUiExtensions);
+ * const merged = mergeSchemas(domainSchema, globalUiExtensions);
+ * const clean = stripUiHelpers(formData, helpers);
+ * ```
+ */
+export { mergeSchemas, getUiHelperFields, stripUiHelpers } from './schema-merge.util';

package/dist/types/app/core/schemas/schema-localization.util.d.ts

@@ -0,0 +1,18 @@
+import { UISchemaElement } from '@jsonforms/core';
+/**
+ * Deeply clones a UI schema and translates its labels.
+ *
+ * This utility is essential for JSONForms integration in a multi-language environment.
+ * Since UI schemas are typically static JSON objects, we must clone them before
+ * modifying their labels to avoid mutating the shared source or leaking translations
+ * across language switches.
+ *
+ * It traverses:
+ * - Nested `elements` arrays (standard layouts)
+ * - `options.detail` objects (often used in array controls)
+ *
+ * @param ui The original UI schema to localize
+ * @param translate A function that takes a translation key and returns the translated string
+ * @returns A new UI schema object with translated labels
+ */
+export declare function cloneAndLocalize(ui: any, translate: (key: string) => string): UISchemaElement;

package/dist/types/app/core/schemas/schema-merge.util.d.ts

@@ -0,0 +1,26 @@
+import { JsonSchema } from '@jsonforms/core';
+/**
+ * Merges a base domain schema with UI-only extension properties at runtime.
+ * Extensions are deep-cloned into the base schema to avoid mutation.
+ *
+ * @param base - Domain schema (e.g., nutrient balance data model)
+ * @param extensions - UI helper schema with `x-ui-helper: true` fields
+ * @returns Merged schema suitable for JSONForms consumption
+ */
+export declare function mergeSchemas(base: JsonSchema, extensions: JsonSchema): JsonSchema;
+/**
+ * Extracts field names marked as UI helpers from a schema.
+ * Scans properties for `"x-ui-helper": true` metadata.
+ *
+ * @param schema - Schema to scan (typically UI extensions schema)
+ * @returns Set of field names that should be filtered from persisted data
+ */
+export declare function getUiHelperFields(schema: JsonSchema): Set<string>;
+/**
+ * Removes all UI helper fields from a data object.
+ * Mutates the input object (use with caution; prefer spreading first).
+ *
+ * @param data - Data object to clean (typically form state)
+ * @param helperFields - Set of field names to remove
+ */
+export declare function stripUiHelpers<T extends Record<string, any>>(data: T, helperFields: Set<string>): Omit<T, string>;

package/dist/types/app/core/schemas/ui-helper-registry.d.ts

@@ -0,0 +1,16 @@
+export interface UiHelperDefinitions {
+    durationSourceType?: 'tvd-original' | 'tvd-final' | 'self-reported';
+    quantity_correction?: boolean;
+}
+export interface UiHelperConfig<K extends keyof UiHelperDefinitions = keyof UiHelperDefinitions> {
+    key: K;
+    default: () => UiHelperDefinitions[K] | undefined;
+    derive?: (domain: any) => UiHelperDefinitions[K] | undefined;
+    readonly?: boolean;
+}
+export declare function getHelperKeys(): (keyof UiHelperDefinitions)[];
+export declare function deriveHelpers(domain: any): Partial<UiHelperDefinitions>;
+export declare function augmentData<T extends object>(domain: T): T & UiHelperDefinitions;
+export declare function stripHelpers<T extends object>(data: T): T;
+export declare function prepareJsonFormsData<T extends object>(domain: T | null | undefined): (T & UiHelperDefinitions) | null;
+export declare function sanitizeJsonFormsData<T extends object>(formData: T): T;

package/dist/types/app/core/telemetry/telemetry.service.d.ts

@@ -0,0 +1,12 @@
+export declare class TelemetryService {
+    private appInsights;
+    private isEnabled;
+    constructor();
+    private init;
+    setTelemetryEnabled(enabled: boolean): void;
+    trackPageView(name?: string, uri?: string): void;
+    trackEvent(name: string, properties?: {
+        [key: string]: any;
+    }): void;
+    trackException(exception: Error): void;
+}

package/dist/types/app/core/utils/object.util.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Recursively compares two values for deep equality.
+ *
+ * Useful for checking if complex objects or arrays have changed content,
+ * often used in change detection strategies or form dirty checking.
+ *
+ * @param a The first value to compare
+ * @param b The second value to compare
+ * @returns True if the values are deeply equal, false otherwise
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Creates a deep copy of a value.
+ *
+ * Essential for immutable state updates where you need to modify a nested property
+ * without mutating the original object.
+ *
+ * Uses `structuredClone` if available, falling back to JSON serialization.
+ * Note: The JSON fallback has limitations (e.g. loses Date objects, functions, undefined).
+ *
+ * @param value The value to clone
+ * @returns A deep copy of the value
+ */
+export declare function deepClone<T>(value: T): T;
+/**
+ * Recursively drops `ingredient[]` entries whose `quantity` is null/undefined.
+ *
+ * Inline tables (fertiliser/recycling) pre-populate every nutrient slot in `ingredient[]`
+ * so the UI always shows all formula columns, but slots the user never fills in stay as
+ * `{ molecularFormula, quantity: null, unit }`. The calculation API rejects any ingredient
+ * entry that's present but incomplete, so submitted payloads must omit those still-empty
+ * slots entirely rather than send them with a null quantity.
+ */
+export declare function stripIncompleteIngredients<T>(value: T): T;
+/**
+ * Sanitizes the planning payload: the calculation API (OpenAPI, no `nullable: true`
+ * anywhere) accepts an optional field as *absent* but rejects it when present with a
+ * null value ("must be string/number"). The working data model normalizes optional
+ * fields to null, so strip them at the submission boundary — mirroring what
+ * `stripIncompleteIngredients` does for ingredient slots.
+ *
+ * - inside `fieldCultivation` entry collections (fodderCropland, arableLand, special,
+ *   feedingOfCropHarvest, dispenseOfCropHarvest): any null property is dropped
+ *   (fieldName, userSpecificPlantName, yieldPerSquareMeasure, effectiveYield, …)
+ * - `nutrientCycle.fodder.trading.<collection>[].quantity`: null → dropped
+ */
+export declare function sanitizePlanningPayload(data: NaebiDataLike): NaebiDataLike;
+/** Structural type so object.util stays free of a NaebiData import (circular-safe). */
+type NaebiDataLike = Record<string, unknown>;
+export {};

package/dist/types/app/core/validation/ajv-custom.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom AJV instance with capability-based validation keywords.
+ * Focus: keep declarative business rules in JSON Schema while deriving dynamic
+ * constraints from static master data (no runtime HTTP calls).
+ */
+import Ajv from 'ajv';
+/**
+ * Creates a custom AJV instance with domain-specific validation keywords.
+ *
+ * Custom keywords:
+ * - `permittedStableSystem`: Validates stable system against animal category constraints
+ *
+ * @param options - Additional AJV options to merge with defaults
+ */
+export declare function createSuibiAjv(options?: Record<string, any>): Ajv;

package/dist/types/app/core/validation/capabilities.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dynamic capability derivation from master data.
+ * Computes permitted stable systems, utilisations, etc. based on animal categories.
+ *
+ * All master data is embedded statically at compile time - no runtime HTTP calls.
+ */
+/**
+ * Derives permitted stable systems (stableSystem enum strings) for a given animal category.
+ *
+ * @param animalCategoryPRIF - The PRIF animal category ID
+ * @returns Array of permitted stableSystem enum strings (e.g. 'HUS_TETHER')
+ */
+export declare function derivePermittedStableSystems(animalCategoryPRIF: number | null | undefined): string[];
+/**
+ * Pre-computed map for performance (memoized at module load).
+ * Maps animalCategoryPRIF -> array of permitted stableSystem enum strings.
+ */
+export declare const PERMITTED_STABLE_SYSTEMS: Record<number, string[]>;

package/dist/types/app/core/validation/error-formatter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Error message formatter for JSON Schema validation.
+ * Maps AJV error objects to i18n keys with parameters.
+ *
+ * Since validation is handled by AJV/JSON Schema, we don't need a custom engine.
+ * We just need to format error messages for better UX.
+ */
+/**
+ * Format an AJV error object for display, mapping to i18n keys where applicable.
+ *
+ * @param error AJV error object
+ * @param translateFn Translation function (key, defaultMessage) => string
+ * @returns Formatted error message
+ */
+export declare function formatValidationError(error: any, translateFn: (key: string, defaultMessage?: string) => string): string;
+/**
+ * Format multiple AJV errors for display.
+ */
+export declare function formatValidationErrors(errors: any[], translateFn: (key: string, defaultMessage?: string) => string): string[];

package/dist/types/app/core/validation/global-validation.service.d.ts

@@ -0,0 +1,59 @@
+import { ErrorObject } from 'ajv';
+import { AnimalStockCategory, FarmManureTradingCategory, FarmManureTradingMode, FieldCultivationTab, FieldSpreadingCategory, FodderCategory, FodderMode, PageId, StorageEntryType, StorageTab } from '../navigation/navigation.service';
+export interface EnrichedValidationError extends ErrorObject {
+    /** Human-friendly field label (e.g., "Animal Category") */
+    fieldLabel?: string;
+    /** Navigation target: page */
+    targetPage?: PageId;
+    /** Navigation target: animal stock array index */
+    targetAnimalStockIndex?: number;
+    /** Navigation target: detail category (tab) */
+    targetCategory?: AnimalStockCategory;
+    /** Navigation target: static section (e.g., lifetime performance panel) */
+    targetSection?: 'lifetimePerformance';
+    /** Navigation target: farm manure trading tab */
+    targetFarmManureTradingMode?: FarmManureTradingMode;
+    /** Navigation target: farm manure trading entry index */
+    targetFarmManureTradingIndex?: number;
+    /** Category tab inside farm manure trading detail */
+    targetFarmManureTradingCategory?: FarmManureTradingCategory;
+    /** Navigation target: fodder mode */
+    targetFodderMode?: FodderMode;
+    /** Navigation target: fodder entry index */
+    targetFodderIndex?: number;
+    /** Category tab inside fodder detail */
+    targetFodderCategory?: FodderCategory;
+    /** Category tab inside field spreading */
+    targetFieldSpreadingCategory?: FieldSpreadingCategory;
+    /** Category tab inside field cultivation */
+    targetFieldCultivationTab?: FieldCultivationTab;
+    /** Field cultivation detail index */
+    targetFieldCultivationIndex?: number;
+    /** Storage detail type */
+    targetStorageType?: StorageEntryType;
+    /** Storage detail index */
+    targetStorageIndex?: number;
+    /** Storage tab for list-level or scalar navigation */
+    targetStorageTab?: StorageTab;
+}
+/**
+ * GlobalValidationService
+ * Validates the entire NaebiData structure using the root JSON Schema + AJV.
+ * Consolidates errors and enriches them with navigation metadata for deep-linking.
+ *
+ * Usage: Inject in App or top-level components; errors() signal exposes enriched errors.
+ */
+export declare class GlobalValidationService {
+    private readonly dataSvc;
+    private readonly ajv;
+    private readonly validateFn;
+    readonly errors: import("@angular/core").Signal<EnrichedValidationError[]>;
+    private consolidateErrors;
+    private enrichErrors;
+    private inferCategory;
+    private inferFarmTradingCategory;
+    private inferFieldSpreadingCategory;
+    private inferFodderCategory;
+    private inferStorageTab;
+    private inferFieldLabel;
+}

package/dist/types/app/jsonforms/constraints/constraint-resolvers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Constraint resolver registry enabling UI schema elements to declare dynamic
+ * visibility rules referencing domain-specific predicates. A resolver is a
+ * pure function returning a boolean. It receives a contextual accessor for
+ * current form data (root object) plus master-data + locale.
+ *
+ * UI schema structured example:
+ * {
+ *   "type": "Constraint",
+ *   "options": {
+ *     "constraint": {
+ *       "resolver": "animalCategory_isPermittedForConcentratedFeedstuffSummering",
+ *       "args": ["#/animalCategoryPRIF"],
+ *       "fallbackVisible": false
+ *     }
+ *   },
+ *   "elements": [ { "type": "Group", ... } ]
+ * }
+ */
+import { MasterDataService } from '../../core/master-data/master-data.service';
+import { I18nService } from '../../core/i18n/i18n.service';
+export interface ConstraintCall {
+    resolver: string;
+    args?: unknown[];
+    fallbackVisible?: boolean;
+}
+export type ConstraintConfig = ConstraintCall;
+export interface ConstraintContext {
+    /** Root data object from JSONForms state */
+    data: unknown;
+    /** Dereference a JSON Pointer (starts with '#/'); returns undefined if invalid */
+    get<T = unknown>(pointer: string): T | undefined;
+    /** Master-data service */
+    masterData: MasterDataService;
+    /** Current locale (from I18nService) */
+    locale: string;
+}
+export type ConstraintResolver = (ctx: ConstraintContext, ...args: any[]) => boolean;
+export declare function registerConstraint(name: string, fn: ConstraintResolver): void;
+/**
+ * Evaluate a constraint configuration.
+ * @param cfg constraint object (or undefined => visible)
+ * @param data current form data root
+ * @param services injected service wrappers
+ * @param ctxOverrides optional context override (testing/extensibility)
+ */
+export declare function evaluateConstraint(cfg: ConstraintConfig | undefined, data: unknown, services: {
+    masterData: MasterDataService;
+    i18n: I18nService;
+}, ctxOverrides?: Partial<ConstraintContext>): boolean;