@agridea/suibi-module 0.1.0-preview.18 → 0.1.0-preview.1f6a532

package/dist/types/app/core/metadata/suibi-metadata.types.d.ts

@@ -1,8 +1,18 @@
 export type SuibiVersion = '1.19' | '1.20';
 export type SubmissionStatus = 'draft' | 'submitted' | 'final';
+/** Which computation modules are active for this dossier. */
+export interface ComputationModules {
+    suisseBilanz: boolean;
+    gmf: boolean;
+    nh3: boolean;
+    impex: boolean;
+    linear: boolean;
+}
+export declare const DEFAULT_COMPUTATION_MODULES: ComputationModules;
 export interface SuibiMetadata {
     title: string;
     suibiVersion: SuibiVersion;
     status: SubmissionStatus;
+    modules: ComputationModules;
 }
 export declare const DEFAULT_SUIBI_METADATA: SuibiMetadata;

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

@@ -1,8 +1,13 @@
-export type PageId = 'welcome' | 'animal_stock' | 'data_preview' | 'storage' | 'field_spreading' | 'farm_manure_trading';
+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.
@@ -38,6 +43,21 @@ export declare class NavigationService {
         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) */
@@ -58,10 +78,18 @@ export declare class NavigationService {
     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;
     /**

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

@@ -0,0 +1,37 @@
+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 _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/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/validation/capabilities.d.ts

@@ -5,14 +5,14 @@
  * All master data is embedded statically at compile time - no runtime HTTP calls.
  */
 /**
- * Derives permitted stable systems (husbandry type IDs) for a given animal category.
+ * Derives permitted stable systems (stableSystem enum strings) for a given animal category.
  *
  * @param animalCategoryPRIF - The PRIF animal category ID
- * @returns Array of permitted husbandry type IDs (stable systems)
+ * @returns Array of permitted stableSystem enum strings (e.g. 'HUS_TETHER')
  */
-export declare function derivePermittedStableSystems(animalCategoryPRIF: number | null | undefined): number[];
+export declare function derivePermittedStableSystems(animalCategoryPRIF: number | null | undefined): string[];
 /**
  * Pre-computed map for performance (memoized at module load).
- * Maps animalCategoryPRIF -> array of permitted stableSystem values.
+ * Maps animalCategoryPRIF -> array of permitted stableSystem enum strings.
  */
-export declare const PERMITTED_STABLE_SYSTEMS: Record<number, number[]>;
+export declare const PERMITTED_STABLE_SYSTEMS: Record<number, string[]>;

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

@@ -1,5 +1,5 @@
 import { ErrorObject } from 'ajv';
-import { AnimalStockCategory, FarmManureTradingCategory, FarmManureTradingMode, FieldSpreadingCategory, PageId } from '../navigation/navigation.service';
+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;
@@ -17,8 +17,24 @@ export interface EnrichedValidationError extends ErrorObject {
     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
@@ -31,14 +47,13 @@ export declare class GlobalValidationService {
     private readonly dataSvc;
     private readonly ajv;
     private readonly validateFn;
-    private readonly rawErrors;
     readonly errors: import("@angular/core").Signal<EnrichedValidationError[]>;
-    constructor();
-    validate(): void;
     private consolidateErrors;
     private enrichErrors;
     private inferCategory;
     private inferFarmTradingCategory;
     private inferFieldSpreadingCategory;
+    private inferFodderCategory;
+    private inferStorageTab;
     private inferFieldLabel;
 }

package/dist/types/app/jsonforms/filters/code-list-filter-resolvers.d.ts

@@ -20,9 +20,11 @@
  */
 import { MasterDataService } from '../../core/master-data/master-data.service';
 import { I18nService } from '../../core/i18n/i18n.service';
+import { NaebiDataService } from '../../core/data/naebi-data.service';
 import { BaseCodeListEntry } from '../shared/option-sources/code-lists';
 export interface FilterContext {
     data: unknown;
+    rootData: unknown;
     get<T = unknown>(pointer: string): T | undefined;
     masterData: MasterDataService;
     locale: string;
@@ -57,4 +59,5 @@ export declare function registerCodeListFilter(name: string, fn: CodeListFilterR
 export declare function evaluateFilter(list: BaseCodeListEntry[], cfg: FilterConfig | undefined, services: {
     masterData: MasterDataService;
     i18n: I18nService;
+    naebiData?: NaebiDataService;
 }, data: unknown): BaseCodeListEntry[];

package/dist/types/app/jsonforms/registry/renderers.registry.d.ts

@@ -3,9 +3,11 @@ import { CodeListSelectRenderer } from '../renderers/controls/selects/code-list/
 import { CardGroupRenderer } from '../renderers/layout/group/card-group.renderer';
 import { PlainGroupRenderer } from '../renderers/layout/group/plain-group.renderer';
 import { LogicalGroupRenderer } from '../renderers/layout/group/logical-group.renderer';
+import { ModuleToggleGroupRenderer } from '../renderers/layout/group/module-toggle-group.renderer';
 import { RankedTester } from '@jsonforms/core';
 import { ConstraintLayoutRenderer } from '../renderers/layout/constraint/constraint-layout.renderer';
 import { SelectedCategoryCategorizationRenderer } from '../renderers/layout/categorization/selected-category-categorization.renderer';
+import { CustomArrayLayoutRenderer } from '../renderers/layout/array/array-layout.renderer';
 export declare const CUSTOM_JSONFORMS_RENDERERS: ({
     tester: RankedTester;
     renderer: typeof ConstraintLayoutRenderer;
@@ -21,10 +23,16 @@ export declare const CUSTOM_JSONFORMS_RENDERERS: ({
 } | {
     tester: RankedTester;
     renderer: typeof LogicalGroupRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof ModuleToggleGroupRenderer;
 } | {
     tester: RankedTester;
     renderer: typeof AnimalCategorySelectRenderer;
 } | {
     tester: RankedTester;
     renderer: typeof CodeListSelectRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof CustomArrayLayoutRenderer;
 })[];

package/dist/types/app/jsonforms/renderers/controls/selects/animal-category/animal-category-select.renderer.d.ts

@@ -10,7 +10,7 @@ interface AnimalCategoryPrifEntry {
     };
 }
 export declare class AnimalCategorySelectRenderer extends BaseSelectControl<number> {
-    options: AnimalCategoryPrifEntry[];
+    options: import("@angular/core").InputSignal<AnimalCategoryPrifEntry[]>;
     private readonly masterData;
     constructor(jsonFormsService: JsonFormsAngularService);
     getEventValue: (event: any) => any;

package/dist/types/app/jsonforms/renderers/controls/selects/code-list/code-list-select.renderer.d.ts

@@ -1,28 +1,34 @@
 import { Signal } from '@angular/core';
 import { JsonFormsAngularService } from '@jsonforms/angular';
-import { RankedTester } from '@jsonforms/core';
+import { ControlElement, RankedTester } from '@jsonforms/core';
 import { BaseSelectControl } from '../../../../shared/base-control/base-select-control';
 import { BaseCodeListEntry } from '../../../../shared/option-sources/code-lists';
+export declare function replaceDataPathLeaf(path: string | null | undefined, replacement: string): string | null;
+export declare function deriveSiblingDependencyPath(uischema: ControlElement | null | undefined, path: string | null | undefined, replacement: string): string | null;
 export declare class CodeListSelectRenderer extends BaseSelectControl<number | string> {
     private readonly masterData;
     private readonly i18n;
+    private readonly naebiData;
     private readonly formData;
     private readonly controlScope;
     private explicitCodeListKey;
     private controlKey;
     private listKey;
     readonly options: Signal<BaseCodeListEntry[]>;
+    readonly isMultiSelect: Signal<boolean>;
     private readonly filterConfig;
+    private readonly emptyHintKey;
     private readonly dependsOnDataPath;
-    private readonly autoDependsOnScope;
+    private readonly autoDependsOnDataPath;
     private scopePointerToDataPath;
-    private replacePointerLeaf;
     private inferListKeyFromScope;
     private readValueAtPath;
     readonly filteredOptions: Signal<BaseCodeListEntry[]>;
     constructor(jsonFormsService: JsonFormsAngularService);
     getEventValue: (event: any) => any;
     optionLabel(opt: BaseCodeListEntry): string;
-    onSelectionChange(value: number | string): void;
+    emptyHint(): string;
+    shouldShowEmptyHint(): boolean;
+    onSelectionChange(value: number | string | Array<number | string>): void;
 }
 export declare const codeListSelectTester: RankedTester;

package/dist/types/app/jsonforms/renderers/layout/array/array-layout.renderer.d.ts

@@ -0,0 +1,43 @@
+import { OnInit } from '@angular/core';
+import { JsonFormsAbstractControl, JsonFormsAngularService } from '@jsonforms/angular';
+import { ArrayLayoutProps, ArrayTranslations, JsonFormsState, OwnPropsOfRenderer, RankedTester, StatePropsOfArrayLayout, UISchemaElement, UISchemaTester } from '@jsonforms/core';
+/**
+ * CustomArrayLayoutRenderer
+ * Overrides the stock JSONForms `ArrayLayoutRenderer` (rank 4 → this is rank 5) to apply
+ * the project UX pattern: centered empty-state placeholder when the array has no entries,
+ * and the full-width dashed add-button always anchored below the list.
+ *
+ * The add button label is driven by `translations.addTooltip` resolved via the JSONForms
+ * i18n pipeline — configure per-array labels there.
+ */
+export declare class CustomArrayLayoutRenderer extends JsonFormsAbstractControl<StatePropsOfArrayLayout> implements OnInit {
+    noData: boolean;
+    /** Indices 0..n-1 used to render per-item cards and drive sort-button disabled state. */
+    indices: number[];
+    translations: ArrayTranslations;
+    showSortButtons: boolean;
+    addItem: (path: string, value: unknown) => () => void;
+    moveItemUp: (path: string, index: number) => () => void;
+    moveItemDown: (path: string, index: number) => () => void;
+    removeItems: (path: string, toDelete: number[]) => () => void;
+    uischemas: {
+        tester: UISchemaTester;
+        uischema: UISchemaElement;
+    }[];
+    constructor(jsonFormsService: JsonFormsAngularService);
+    get emptyText(): string;
+    get addLabel(): string;
+    mapToProps(state: JsonFormsState): StatePropsOfArrayLayout & {
+        translations: ArrayTranslations;
+    };
+    mapAdditionalProps(props: ArrayLayoutProps & {
+        translations: ArrayTranslations;
+    }): void;
+    remove(index: number): void;
+    add(): void;
+    up(index: number): void;
+    down(index: number): void;
+    ngOnInit(): void;
+    getProps(index: number): OwnPropsOfRenderer;
+}
+export declare const customArrayLayoutRendererTester: RankedTester;

package/dist/types/app/jsonforms/renderers/layout/categorization/selected-category-categorization.renderer.d.ts

@@ -19,12 +19,15 @@ export declare class SelectedCategoryCategorizationRenderer extends JsonFormsBas
     categoryLabels: string[];
     private readonly categoryKeyToIndex;
     private readonly indexToCategoryKey;
+    private _prevCategorySignature;
     readonly selectedTabIndex: import("@angular/core").Signal<number>;
     ngOnInit(): void;
     /**
      * Build bidirectional category key ↔ tab index mapping from UI schema.
      * Reads options.categoryKey from each visible Category element.
      * Example: { base: 0, formOfDetention: 1, feeding: 2 }
+     * Skips signal writes when the tab structure hasn't changed (pure data changes
+     * fire $state on every keystroke; no need to mark selectedTabIndex stale each time).
      */
     private buildCategoryMappings;
     onTabChange(newIndex: number): void;

package/dist/types/app/jsonforms/renderers/layout/constraint/constraint-layout.renderer.d.ts

@@ -12,6 +12,7 @@ export declare class ConstraintLayoutRenderer extends JsonFormsBaseRenderer<Layo
     private readonly service;
     private childrenHost?;
     private subscription;
+    private _prevSig?;
     private _elements;
     private _schema;
     private _path;

package/dist/types/app/jsonforms/renderers/layout/group/base-group.renderer.d.ts

@@ -21,6 +21,8 @@ export declare class BaseGroupRenderer extends JsonFormsBaseRenderer<GroupLayout
     registryRenderers(): JsonFormsRendererRegistryEntry[];
     registryCells(): JsonFormsCellRendererRegistryEntry[] | undefined;
     private subscription;
+    private _destroyed;
+    private _prevSig?;
     ngOnInit(): void;
     ngOnDestroy(): void;
     protected resolveHost(): ViewContainerRef | undefined;

package/dist/types/app/jsonforms/renderers/layout/group/module-toggle-group.renderer.d.ts

@@ -0,0 +1,36 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { JsonFormsBaseRenderer } from '@jsonforms/angular';
+import { GroupLayout, RankedTester } from '@jsonforms/core';
+interface ModuleCard {
+    path: string;
+    value: boolean;
+    label: string;
+    description?: string;
+}
+export declare const moduleToggleGroupTester: RankedTester;
+/**
+ * Layout renderer for `{ type: 'Group', options: { variant: 'module-toggle' } }`.
+ *
+ * Renders boolean control children as interactive card-toggles in a horizontal
+ * row. Label and description are read from the (already-localised) schema that
+ * JSONForms passes into the renderer, so no extra i18n wiring is needed here.
+ */
+export declare class ModuleToggleGroupRenderer extends JsonFormsBaseRenderer<GroupLayout> implements OnInit, OnDestroy {
+    private readonly service;
+    private readonly cdr;
+    private subscription?;
+    protected readonly _hidden: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _label: import("@angular/core").WritableSignal<string | undefined>;
+    protected readonly _description: import("@angular/core").WritableSignal<string | undefined>;
+    protected readonly _modules: import("@angular/core").WritableSignal<ModuleCard[]>;
+    readonly labelId: string;
+    hidden: () => boolean;
+    label: () => string | undefined;
+    description: () => string | undefined;
+    modules: () => ModuleCard[];
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Flip a single module boolean in the JSONForms data store. */
+    toggle(dataPath: string): void;
+}
+export {};

package/dist/types/app/nutrient-cycle/animal-stock/animal-stock-detail.component.d.ts

@@ -1,17 +1,16 @@
-import { EventEmitter, Signal } from '@angular/core';
 import { JsonSchema, UISchemaElement } from '@jsonforms/core';
 import { AnimalStockRow } from './animal-stock.types';
 import { ErrorObject } from 'ajv';
 export declare class AnimalStockDetailComponent {
     private readonly i18n;
-    row: Signal<AnimalStockRow | null>;
-    index: Signal<number | null>;
-    rowChange: EventEmitter<AnimalStockRow>;
-    close: EventEmitter<void>;
-    itemSchema: Signal<JsonSchema>;
+    row: import("@angular/core").InputSignal<AnimalStockRow | null>;
+    index: import("@angular/core").InputSignal<number | null>;
+    rowChange: import("@angular/core").OutputEmitterRef<AnimalStockRow>;
+    close: import("@angular/core").OutputEmitterRef<void>;
+    itemSchema: import("@angular/core").Signal<JsonSchema>;
     private readonly baseUi;
-    localizedUi: Signal<UISchemaElement>;
-    jsonFormsData: Signal<(AnimalStockRow & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    localizedUi: import("@angular/core").Signal<UISchemaElement>;
+    jsonFormsData: import("@angular/core").Signal<(AnimalStockRow & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     readonly renderers: {
         tester: import("@jsonforms/core").RankedTester;
         renderer: any;