@agridea/suibi-module 0.1.0-preview.9159a63 → 0.1.0-preview.9c2f7b8

package/dist/elements/browser/version.txt

@@ -1 +1 @@
-0.1.0-preview.9159a63 9159a63
+0.1.0-preview.9c2f7b8 9c2f7b8

package/dist/types/app/components/inline-table/inline-table.component.d.ts

@@ -1,5 +1,6 @@
+import { MatCheckboxChange } from '@angular/material/checkbox';
 import { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/code-lists';
-import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
+import { InlineColumnDef, InlineTableConfig, InlineCellErrorResolver } from './inline-table.types';
 /**
  * InlineTableComponent — generic inline-editable table for array-of-objects data.
  *
@@ -26,6 +27,8 @@ import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
  */
 export declare class InlineTableComponent {
     private readonly i18n;
+    private readonly host;
+    constructor();
     /** Table configuration — columns, labels, and the row factory. Acts as the "uischema". */
     readonly config: import("@angular/core").InputSignal<InlineTableConfig>;
     /** Current array of row objects. Each key maps to a column's `key` or sub-array path. */
@@ -38,17 +41,35 @@ export declare class InlineTableComponent {
     /**
      * Optional business-logic transform applied after every cell edit — before emission.
      *
-     * Signature: `(changedKey, newValue, updatedRow) => transformedRow`
+     * Signature: `(changedKey, newValue, updatedRow, previousRow) => transformedRow`
      *
      * - `changedKey`: the `InlineColumnDef.key` of the edited column.
      * - `newValue`: the raw new value (string, number, or null).
      * - `updatedRow`: the row object already reflecting the edit.
+     * - `previousRow`: the row as it was before the edit — needed when the side-effect
+     *   depends on the replaced value (e.g. converting a quantity on a unit switch).
      * - Return the row (possibly further mutated) that should be stored.
      *
      * Use this for cross-field side-effects such as pre-populating nutrient % columns
      * when a product is selected.  For forms without such logic, omit this input.
      */
-    readonly rowTransform: import("@angular/core").InputSignal<((changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>) | null>;
+    readonly rowTransform: import("@angular/core").InputSignal<((changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>) | null>;
+    /**
+     * Optional per-cell validation resolver — returns a translated error message
+     * shown under the cell (cell turns red via `mat-form-field-invalid`), or `null`
+     * when valid. Inline tables bypass JSONForms/AJV, so business rules that must
+     * be visible while typing (e.g. percentage caps) are surfaced through this hook.
+     */
+    readonly cellError: import("@angular/core").InputSignal<InlineCellErrorResolver | null>;
+    /**
+     * Index of the row to visually highlight (e.g. after a validation-error deep-link).
+     * Also triggers a scrollIntoView so the row is on screen.
+     */
+    readonly highlightRowIndex: import("@angular/core").InputSignal<number | null>;
+    /** Resolves the per-cell error message via the optional `cellError` input (null = valid). */
+    errorForCell(row: Record<string, unknown>, col: InlineColumnDef): string | null;
+    /** True when any column of the row reports an error — drives the row-level red tint. */
+    rowHasError(row: Record<string, unknown>): boolean;
     /** Extracts a px value from a grid-format width string (e.g. 'minmax(120px, 1fr)' → '120px'). */
     colMinWidth(width?: string): string;
     /** Total table width = sum of all column px values + 40px for the delete column. */
@@ -62,8 +83,12 @@ export declare class InlineTableComponent {
     readonly emptyHint: import("@angular/core").Signal<string>;
     /** Returns the option array for a select column from the shared CODE_LISTS map. */
     getOptions(col: InlineColumnDef): BaseCodeListEntry[];
+    /** Options for a select column, narrowed per row when the column defines `optionsFilter`. */
+    optionsForRow(col: InlineColumnDef, row: Record<string, unknown>): BaseCodeListEntry[];
     /**
      * Returns the localized display label for a code-list option.
+     * - `optionLabelKey`: translates the i18n key returned by the column's resolver — for
+     *   literal option lists whose labels live in the locales rather than in master data.
      * - `optionDisplay: 'id'`: returns `String(entry.id)` (e.g. "kg", "t").
      * - default (`'label'`): uses `descriptor.designation_eng / designation_deu`;
      *   falls back to `String(entry.id)` when no descriptor is present.
@@ -72,6 +97,7 @@ export declare class InlineTableComponent {
     /**
      * Reads the current cell value for a column from a row object.
      *
+     * - `valueResolver` columns: fully derived value (e.g. from master data).
      * - Simple field: returns `row[col.key]`.
      * - Sub-array field: navigates `row[arrayPath]`, finds the entry matching
      *   `arrayKeyField === arrayKeyValue`, and returns `entry[arrayValueField]`.
@@ -84,14 +110,47 @@ export declare class InlineTableComponent {
     private setValue;
     /** Called when a `mat-select` selection changes. */
     onSelectChange(rowIdx: number, col: InlineColumnDef, value: unknown): void;
-    /** Called on `(change)` of a number `<input>` — parses the string value and guards NaN. */
+    /** Called on `(input)` of a number `<input>` — parses the string value and guards NaN.
+     *  Uses `input` (not `change`) so every keystroke commits immediately: relying on blur
+     *  meant edits were lost whenever the table was destroyed before the field lost focus
+     *  (e.g. navigating to another page), even though switching same-page tabs hid the bug
+     *  since mat-tab-group keeps inactive tab content mounted. */
     onNumberChange(rowIdx: number, col: InlineColumnDef, event: Event): void;
-    /** Called on `(change)` of a text `<input>`. */
+    /** Called on `(input)` of a text `<input>` (see onNumberChange for why not `(change)`). */
     onTextChange(rowIdx: number, col: InlineColumnDef, event: Event): void;
+    /** Called when a `mat-checkbox` is toggled. */
+    onCheckboxChange(rowIdx: number, col: InlineColumnDef, change: MatCheckboxChange): void;
+    /** Whether the cell widget is disabled for this row (per-row constraint hook). */
+    isCellDisabled(col: InlineColumnDef, row: Record<string, unknown>): boolean;
     /** Appends a blank row produced by `config.createRow()`. */
     addRow(): void;
     /** Removes the row at `idx` from the array. */
     removeRow(idx: number): void;
+    /** Ids of the expanded sub-rows panels, keyed `${rowIdx}:${col.key}` (UI-only state). */
+    private readonly expandedSubrows;
+    isSubrowsExpanded(rowIdx: number, col: InlineColumnDef): boolean;
+    toggleSubrows(rowIdx: number, col: InlineColumnDef): void;
+    /** Reads the nested key/value entries of a sub-rows column (never null). */
+    getSubEntries(row: Record<string, unknown>, col: InlineColumnDef): Record<string, unknown>[];
+    /** Options for the key select of a sub-rows column. */
+    getSubrowOptions(col: InlineColumnDef): BaseCodeListEntry[];
+    /** Localized label for a sub-entry key (descriptor designation, id as fallback). */
+    subrowKeyLabel(col: InlineColumnDef, keyValue: unknown): string;
+    /** Collapsed-cell summary, e.g. "Bovins 25 %, Porcs 75 %" ('–' when empty). */
+    subrowsSummary(row: Record<string, unknown>, col: InlineColumnDef): string;
+    /** Sum of the value fields of all sub-entries. */
+    subEntryTotal(row: Record<string, unknown>, col: InlineColumnDef): number;
+    /** Whether the sub-entry values sum to the configured expected total. */
+    subEntryTotalOk(row: Record<string, unknown>, col: InlineColumnDef): boolean;
+    addSubEntry(rowIdx: number, col: InlineColumnDef): void;
+    removeSubEntry(rowIdx: number, col: InlineColumnDef, subIdx: number): void;
+    onSubEntryKeyChange(rowIdx: number, col: InlineColumnDef, subIdx: number, value: unknown): void;
+    /** Commits on every keystroke (not on blur) — same rationale as `onNumberChange`.
+     *  When `expectedTotal` is set, the value is clamped to the remaining share so the
+     *  sum can never exceed it; smaller intermediate keystrokes still go through. */
+    onSubEntryValueChange(rowIdx: number, col: InlineColumnDef, subIdx: number, event: Event): void;
+    /** Writes the sub-entry array back to the row, runs rowTransform, emits rowsChange. */
+    private updateSubEntries;
     /**
      * Core change handler: sets the new value on the row, applies the optional
      * `rowTransform` for any cross-field side-effects, then emits the updated array.

package/dist/types/app/components/inline-table/inline-table.types.d.ts

@@ -11,8 +11,58 @@
  * To reuse the table for a different domain, create a new config file and a thin
  * wrapper component.  Only the config changes; the rendering component stays the same.
  */
-/** Supported cell widget types. Extend with new literal types as needed. */
-export type InlineCellType = 'select' | 'number' | 'text';
+import type { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/code-lists';
+/** Supported cell widget types. Extend with new literal types as needed.
+ *  'readonly' renders the resolved value as plain text (no input) — for columns
+ *  that are fully derived from other fields and must not be user-editable.
+ *  'checkbox' renders a boolean mat-checkbox bound to a true/false row field.
+ *  'subrows' renders an expandable editor for a nested list of key/percentage
+ *  pairs (e.g. manureDerivation[]) — see `InlineSubrowsConfig`. */
+export type InlineCellType = 'select' | 'number' | 'text' | 'readonly' | 'checkbox' | 'subrows';
+/**
+ * Per-cell validation resolver — returns a translated error message to display
+ * under the cell, or `null` when the cell is valid. Passed as the `cellError`
+ * input of InlineTableComponent for domain tables that bypass JSONForms/AJV
+ * (inline tables are not schema-validated, so business rules like percentage
+ * caps must be surfaced visually through this hook).
+ */
+export type InlineCellErrorResolver = (row: Record<string, unknown>, col: InlineColumnDef) => string | null;
+/**
+ * Configuration for a `type: 'subrows'` column — an expandable editor for a nested
+ * array of `{ key, value }` entries (e.g. manureDerivation: zoologicalAnimal +
+ * percentageAllocation). The collapsed cell shows a joined summary; expanding it
+ * opens a floating panel with one select + number input per entry, an add button,
+ * and a total indicator (green when the sum matches `expectedTotal`).
+ */
+export interface InlineSubrowsConfig {
+    /** Path to the nested array on the row object (e.g. `'manureDerivation'`). */
+    arrayPath: string;
+    /** Field holding the code-list key in each sub-entry (e.g. `'zoologicalAnimal'`). */
+    keyField: string;
+    /** Key into the shared `CODE_LISTS` map for the key select options. */
+    keyCodeListKey: string;
+    /** i18n key for the key sub-column header inside the panel. */
+    keyLabelKey: string;
+    /** Field holding the numeric share in each sub-entry (e.g. `'percentageAllocation'`). */
+    valueField: string;
+    /** i18n key for the value sub-column header inside the panel. */
+    valueLabelKey: string;
+    /** i18n key for the "add sub-entry" button label. */
+    addLabelKey: string;
+    /** i18n key for the expand toggle label (collapsed state). */
+    expandLabelKey: string;
+    /** i18n key for the collapse toggle label (expanded state). */
+    collapseLabelKey: string;
+    /** i18n key for the total indicator label. */
+    totalLabelKey: string;
+    /** Expected sum of the value fields (e.g. 100) — the indicator turns green on exact
+     *  match (no more, no less) and entered values are clamped so the sum never exceeds it. */
+    expectedTotal?: number;
+    /** Min for the value number input (default 0). */
+    valueMin?: number;
+    /** Max for the value number input (default: none). */
+    valueMax?: number;
+}
 /**
  * Definition for a single column in an inline table.
  *
@@ -55,6 +105,24 @@ export interface InlineColumnDef {
      *   human-readable (e.g. unit codes like "kg", "t", "l").
      */
     optionDisplay?: 'label' | 'id';
+    /**
+     * For `type: 'select'` — optional per-row narrowing of the code-list options,
+     * e.g. to restrict the product list based on another cell of the same row.
+     * Evaluated for every option of every row, so keep it cheap.
+     */
+    optionsFilter?: (entry: BaseCodeListEntry, row: Record<string, unknown>) => boolean;
+    /**
+     * For `type: 'select'` — resolve an option's label through an i18n key instead of the
+     * master-data descriptor (for literal option lists whose labels live in the locales,
+     * e.g. a row-type selector). Takes precedence over `optionDisplay`.
+     */
+    optionLabelKey?: (entry: BaseCodeListEntry) => string;
+    /**
+     * Optional i18n key for an explanatory tooltip shown via an info icon next to
+     * the column header (e.g. to explain a checkbox whose effect is not obvious).
+     * Omit for columns that need no extra explanation.
+     */
+    tooltipKey?: string;
     /**
      * CSS grid column-sizing token, e.g. `'minmax(140px, 2fr)'` or `'84px'`.
      * These values are joined to build the `grid-template-columns` style on the table.
@@ -70,6 +138,18 @@ export interface InlineColumnDef {
      * Defaults to `'any'` when omitted, allowing any decimal.
      */
     step?: string;
+    /**
+     * Custom cell-value resolver — takes precedence over the default read path.
+     * Use this for `type: 'readonly'` columns whose value is derived from master
+     * data or other cells (e.g. a standard yield looked up from the selected crop)
+     * and therefore does not live on the row object.
+     */
+    valueResolver?: (row: Record<string, unknown>) => unknown;
+    /**
+     * Per-row disabling of the cell widget (e.g. grey out the yield input when the
+     * selected crop does not permit yield input). Evaluated per row, keep it cheap.
+     */
+    disabledForRow?: (row: Record<string, unknown>) => boolean;
     /**
      * Sub-array navigation config — for columns whose value lives inside a nested array
      * on the row object (e.g. `ingredient[].quantity`).
@@ -90,6 +170,11 @@ export interface InlineColumnDef {
     arrayKeyField?: string;
     arrayKeyValue?: string;
     arrayValueField?: string;
+    /**
+     * Sub-rows editor config — required when `type: 'subrows'`, ignored otherwise.
+     * Drives the expandable key/percentage pair editor (see `InlineSubrowsConfig`).
+     */
+    subrows?: InlineSubrowsConfig;
 }
 /**
  * Full configuration for one inline-table instance — the "uischema" equivalent.

package/dist/types/app/components/suissebilanz-dashboard/suissebilanz-dashboard.component.d.ts

@@ -11,6 +11,8 @@ import { SuisseBilanzMetricsService } from './suissebilanz-metrics.service';
  */
 export declare class SuisseBilanzDashboardComponent {
     readonly embedded: import("@angular/core").InputSignal<boolean>;
+    /** Shows the official PDF download link even when `embedded` (header hidden). */
+    readonly showPdfButton: import("@angular/core").InputSignal<boolean>;
     protected readonly planning: PlanningBalanceService;
     private readonly sanitizer;
     protected readonly metricsService: SuisseBilanzMetricsService;

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

@@ -8,6 +8,7 @@ export declare class I18nService {
     readonly jsonFormsI18n: Signal<{
         locale: Locale;
         translate: JsonFormsTranslator;
+        translateError: (error: unknown, translate: JsonFormsTranslator) => string;
     }>;
     setLocale(locale: Locale): void;
     /** Returns true if the given string is a supported locale key. */

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

@@ -1,4 +1,4 @@
-export type SuibiVersion = '1.19' | '1.20';
+export type SuibiVersion = 'v2.0';
 export type SubmissionStatus = 'draft' | 'submitted' | 'final';
 /** Which computation modules are active for this dossier. */
 export interface ComputationModules {

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

@@ -58,6 +58,11 @@ export declare class NavigationService {
         type: StorageEntryType;
         index: number;
     } | null>;
+    /** Selected field spreading row context (category/tab + row index) — used by validation deep-links */
+    readonly selectedFieldSpreadingDetail: import("@angular/core").WritableSignal<{
+        category: FieldSpreadingCategory;
+        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) */
@@ -81,6 +86,8 @@ export declare class NavigationService {
     navigateToFodderDetail(mode: FodderMode, index: number, category?: FodderCategory): void;
     navigateToFodderList(): void;
     navigateToFieldSpreading(category?: FieldSpreadingCategory): void;
+    /** Deep-link to a specific row of a field spreading tab (e.g. from a validation error). */
+    navigateToFieldSpreadingDetail(category: FieldSpreadingCategory, index: number): void;
     navigateToFieldCultivationDetail(tab: Exclude<FieldCultivationTab, 'general'>, index: number): void;
     navigateToFieldCultivationList(tab?: FieldCultivationTab): void;
     navigateToStorageDetail(type: StorageEntryType, index: number): void;

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

@@ -11,6 +11,7 @@ export type PlanningEndpoint = 'ebilanz' | 'blw';
  */
 export declare class PlanningBalanceService {
     private readonly http;
+    private readonly metadataSvc;
     private readonly _value;
     private readonly _error;
     private readonly _isLoading;

package/dist/types/app/core/utils/custom-unit.util.d.ts

@@ -0,0 +1,38 @@
+export interface CustomUnit {
+    /** Unit code stored on the row (e.g. 'ha', 't', 'dt'). */
+    code: string;
+    /** API base unit this custom unit converts to (e.g. 'm2', 'kg'). */
+    baseUnit: string;
+    /** Multiplier from the custom unit to its base unit (1 ha = 10'000 m2 → 10000). */
+    factor: number;
+    descriptor?: Record<string, unknown>;
+}
+export declare const CUSTOM_UNITS: readonly CustomUnit[];
+/** True when the unit code is a custom display unit (not an API base unit). */
+export declare function isCustomUnit(unit: unknown): boolean;
+/** Base unit a quantity can be converted to: the custom unit's `baseUnit`, or the unit
+ *  itself when it already is a base (or unknown) unit. */
+export declare function baseUnitOf(unit: string | null | undefined): string | null | undefined;
+/** Custom units convertible to the given base unit (e.g. 'kg' → [t, dt]). */
+export declare function customUnitsForBaseUnit(baseUnit: string): CustomUnit[];
+/**
+ * Builds a filter (compatible with the inline table's `optionsFilter`) keeping only the
+ * units compatible with the given context base unit — i.e. the base unit itself plus its
+ * custom units. Pass a nullable base (e.g. derived from a product's matterState): `null`
+ * keeps the full list (nothing derived yet).
+ *
+ * Works on any entry shape exposing `id` (and `baseUnit` for custom units).
+ */
+export declare function unitOptionsForBaseUnit<T extends {
+    id: string | number;
+}>(contextBaseUnit: string | null | undefined): (entry: T) => boolean;
+/** Converts a quantity expressed in a custom unit to its base unit; pass-through for
+ *  base/unknown units and null quantities. */
+export declare function convertToBaseUnit(quantity: number | null | undefined, unit: string | null | undefined): {
+    quantity: number | null | undefined;
+    unit: string | null | undefined;
+};
+/** Converts a quantity between two units sharing the same base unit (kg ↔ t ↔ dt,
+ *  m2 ↔ ha). Returns the quantity unchanged when either unit is missing or the units
+ *  are incompatible (different base units). */
+export declare function convertQuantityBetween(quantity: number | null | undefined, fromUnit: string | null | undefined, toUnit: string | null | undefined): number | null | undefined;

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

@@ -22,3 +22,20 @@ export declare function deepEqual(a: unknown, b: unknown): boolean;
  * @returns A deep copy of the value
  */
 export declare function deepClone<T>(value: T): T;
+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

@@ -9,6 +9,7 @@ import Ajv from 'ajv';
  *
  * Custom keywords:
  * - `permittedStableSystem`: Validates stable system against animal category constraints
+ * - `proportionSum`: Validates the sum of one numeric field across array items
  *
  * @param options - Additional AJV options to merge with defaults
  */

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

@@ -25,6 +25,8 @@ export interface EnrichedValidationError extends ErrorObject {
     targetFodderCategory?: FodderCategory;
     /** Category tab inside field spreading */
     targetFieldSpreadingCategory?: FieldSpreadingCategory;
+    /** Row index inside a field spreading tab (fertiliser/recycling) */
+    targetFieldSpreadingIndex?: number;
     /** Category tab inside field cultivation */
     targetFieldCultivationTab?: FieldCultivationTab;
     /** Field cultivation detail index */

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

@@ -20,17 +20,19 @@ export declare class ModuleToggleGroupRenderer extends JsonFormsBaseRenderer<Gro
     private readonly cdr;
     private subscription?;
     protected readonly _hidden: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _enabled: 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;
+    enabled: () => boolean;
     label: () => string | undefined;
     description: () => string | undefined;
     modules: () => ModuleCard[];
     ngOnInit(): void;
     ngOnDestroy(): void;
-    /** Flip a single module boolean in the JSONForms data store. */
+    /** Flip a single module boolean in the JSONForms data store. No-op while the group is disabled. */
     toggle(dataPath: string): void;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { JsonSchema, UISchemaElement } from '@jsonforms/core';
-import { AnimalStockRow } from './animal-stock.types';
+import { AnimalStockRow } from '../animal-stock.types';
 import { ErrorObject } from 'ajv';
 export declare class AnimalStockDetailComponent {
     private readonly i18n;
@@ -10,7 +10,7 @@ export declare class AnimalStockDetailComponent {
     itemSchema: import("@angular/core").Signal<JsonSchema>;
     private readonly baseUi;
     localizedUi: import("@angular/core").Signal<UISchemaElement>;
-    jsonFormsData: import("@angular/core").Signal<(AnimalStockRow & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    jsonFormsData: import("@angular/core").Signal<(AnimalStockRow & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     readonly renderers: {
         tester: import("@jsonforms/core").RankedTester;
         renderer: any;

package/dist/types/app/nutrient-cycle/animal-stock/{animal-stock-list.component.d.ts → animal-stock-list/animal-stock-list.component.d.ts}

@@ -1,5 +1,5 @@
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
-import { AnimalStockRow } from './animal-stock.types';
+import { AnimalStockRow } from '../animal-stock.types';
 export declare class AnimalStockListComponent {
     private readonly masterData;
     rows: import("@angular/core").InputSignal<AnimalStockRow[]>;

package/dist/types/app/nutrient-cycle/animal-stock/{animal-stock-master-detail.component.d.ts → animal-stock-master-detail/animal-stock-master-detail.component.d.ts}

@@ -1,5 +1,5 @@
-import { AnimalStockRow } from './animal-stock.types';
-import { LifetimePerformance } from '../lifetime-performance/lifetime-performance.types';
+import { AnimalStockRow } from '../animal-stock.types';
+import { LifetimePerformance } from '../../lifetime-performance/lifetime-performance.types';
 export declare class AnimalStockMasterDetailComponent {
     private readonly dataSvc;
     private readonly navigationSvc;

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

@@ -1,4 +1,4 @@
-export * from './animal-stock-list.component';
-export * from './animal-stock-detail.component';
-export * from './animal-stock-master-detail.component';
+export * from './animal-stock-list/animal-stock-list.component';
+export * from './animal-stock-detail/animal-stock-detail.component';
+export * from './animal-stock-master-detail/animal-stock-master-detail.component';
 export * from './animal-stock.types';

package/dist/types/app/nutrient-cycle/farm-manure-trading/farm-manure-trading-master-detail/farm-manure-trading-master-detail.component.d.ts

@@ -0,0 +1,19 @@
+import { FarmManureTradingSupply, FarmManureTradingDispense } from '../farm-manure-trading.types';
+/**
+ * Farm manure trading page — two inline tables (supply "Reprises" / dispense
+ * "Cessions") editing `nutrientCycle.farmManureTrading` directly. The former
+ * master-detail round-trip (list + JSONForms detail pane) was replaced by inline
+ * editing, so validation deep-links (`selectedFarmManureTrading`) are merely
+ * consumed and cleared — there is no detail pane left to open (fodder pattern).
+ */
+export declare class FarmManureTradingMasterDetailComponent {
+    private readonly dataSvc;
+    private readonly navigationSvc;
+    constructor();
+    readonly supplyRows: import("@angular/core").Signal<FarmManureTradingSupply[]>;
+    readonly dispenseRows: import("@angular/core").Signal<FarmManureTradingDispense[]>;
+    onSupplyChange(rows: FarmManureTradingSupply[]): void;
+    onDispenseChange(rows: FarmManureTradingDispense[]): void;
+    private patchRows;
+    private cloneTrading;
+}

package/dist/types/app/nutrient-cycle/farm-manure-trading/farm-manure-trading-table/farm-manure-trading-table.component.d.ts

@@ -0,0 +1,35 @@
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+import { FarmManureTradingMode } from '../../../core/navigation/navigation.service';
+import { FarmManureTradingSupply, FarmManureTradingDispense } from '../farm-manure-trading.types';
+type TradingRow = FarmManureTradingSupply | FarmManureTradingDispense;
+/**
+ * FarmManureTradingTableComponent — thin wrapper around InlineTableComponent.
+ *
+ * Responsibilities:
+ *   1. Provides the per-mode column/section config (the "uischema").
+ *   2. Bridges typed `FarmManureTradingSupply[]`/`Dispense[]` to/from the generic
+ *      `Record<string, unknown>[]` API of InlineTableComponent.
+ *   3. Supplies `deriveUnits` as a `rowTransform` — the base `transactionUnit` ('kg'/'m3')
+ *      and every ingredient's `unit` ('kg/t'/'kg/m3') are derived from the selected
+ *      product's matterState; the user may switch to a custom unit sharing the same base
+ *      (t, dt for kg), which converts the entered quantity on the fly.
+ */
+export declare class FarmManureTradingTableComponent {
+    readonly mode: import("@angular/core").InputSignal<FarmManureTradingMode>;
+    readonly entries: import("@angular/core").InputSignal<TradingRow[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<TradingRow[]>;
+    protected readonly config: import("@angular/core").Signal<InlineTableConfig>;
+    /** Cast typed entries to generic Record[] for InlineTableComponent. */
+    readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
+    /** Cast generic output back to typed trading rows. */
+    onRowsChange(rows: Record<string, unknown>[]): void;
+    /**
+     * Row transform deriving the ingredient units from the product's matterState on each
+     * edit, and handling `transactionUnit`:
+     *  - product change (or missing unit on legacy rows): reset to the derived base unit,
+     *  - unit switch: convert the entered quantity from the previous to the new unit
+     *    (both share the same base), so the transacted amount is preserved.
+     */
+    readonly deriveUnits: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
+}
+export {};

package/dist/types/app/nutrient-cycle/farm-manure-trading/farm-manure-trading-table/farm-manure-trading-table.config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Column and section configuration for the Farm Manure Trading inline tables.
+ *
+ * This is the "uischema" for the supply ("Reprises") and dispense ("Cessions")
+ * tables — one InlineTableConfig per mode, mirroring recycling-table.config.ts.
+ * Columns:
+ *   - Product:        typeOfManureRecyclingProduct (code list filtered per mode)
+ *   - Quantity:       quantity (number)
+ *   - Unit:           transactionUnit (readonly — derived from the product's
+ *                     matterState, never user-editable, per the API spec)
+ *   - Origin:         manureDerivation[] (expandable key/share pair editor,
+ *                     expected total 100 %)
+ *   - Nutrients:      Ntot, Nsol (molecularFormula 'Nlos'), P₂O₅, K₂O, Mg read/written
+ *                     via the ingredient[] sub-array (same 5 nutrients as recycling).
+ *   - Nutrient unit:  readonly, derived from the product's matterState (kg/t | kg/m³).
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+import type { FarmManureTradingMode } from '../../../core/navigation/navigation.service';
+/** Nutrient formulas tracked per trading entry, in display order. 'Nlos' = soluble nitrogen
+ *  (matches the `molecularFormula` enum from assets/master-data/substances.json — there is no 'NSol'). */
+export declare const TRADING_NUTRIENT_COLUMNS: readonly ["Ntot", "Nlos", "P2O5", "K2O", "Mg"];
+export type TradingNutrientFormula = (typeof TRADING_NUTRIENT_COLUMNS)[number];
+/** Builds the inline-table config for one mode ('supply' | 'dispense'). */
+export declare function createTradingTableConfig(mode: FarmManureTradingMode): InlineTableConfig;

package/dist/types/app/nutrient-cycle/farm-manure-trading/farm-manure-trading.types.d.ts

@@ -10,6 +10,8 @@ export interface ManureDerivation {
 export interface FarmManureTradingSupply {
     quantity?: number;
     typeOfManureRecyclingProduct?: string;
+    /** Host-only free text: persisted in the emitted dossier, stripped before API calls. */
+    productDesignation?: string;
     transactionUnit?: string;
     manureDerivation?: ManureDerivation[];
     ingredient?: ManureIngredient[];
@@ -17,6 +19,8 @@ export interface FarmManureTradingSupply {
 export interface FarmManureTradingDispense {
     quantity?: number;
     typeOfManureRecyclingProduct?: string;
+    /** Host-only free text: persisted in the emitted dossier, stripped before API calls. */
+    productDesignation?: string;
     transactionUnit?: string;
     manureDerivation?: ManureDerivation[];
     ingredient?: ManureIngredient[];

package/dist/types/app/nutrient-cycle/farm-manure-trading/index.d.ts

@@ -1,4 +1,4 @@
-export * from './farm-manure-trading-list.component';
-export * from './farm-manure-trading-detail.component';
-export * from './farm-manure-trading-master-detail.component';
+export * from './farm-manure-trading-table/farm-manure-trading-table.component';
+export * from './farm-manure-trading-table/farm-manure-trading-table.config';
+export * from './farm-manure-trading-master-detail/farm-manure-trading-master-detail.component';
 export * from './farm-manure-trading.types';

package/dist/types/app/nutrient-cycle/farm-manure-trading/transaction-unit.util.d.ts

@@ -1 +1,3 @@
 export declare function deriveTransactionUnit(productCode: string | null | undefined): string | undefined;
+/** Derives the mandatory ingredient unit ('kg/t' or 'kg/m3') from the product's matterState. */
+export declare function deriveTradingIngredientUnit(productCode: string | null | undefined): string | undefined;

package/dist/types/app/nutrient-cycle/field-cultivation/arable-land-table/arable-land-table.component.d.ts

@@ -0,0 +1,22 @@
+import { FieldCultivationArableLand } from '../field-cultivation.types';
+/**
+ * ArableLandTableComponent — thin wrapper around InlineTableComponent for the
+ * "Grandes cultures" tab: arable-land entries are edited directly in the table
+ * (no detail pane). The config provides the columns; the rowTransform clears the
+ * yield-related fields when the newly selected crop does not permit yield input.
+ */
+export declare class ArableLandTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FieldCultivationArableLand[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldCultivationArableLand[]>;
+    /** Column/section config (constant — no signal needed). */
+    protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
+    /** Cast typed entries to the generic Record[] expected by InlineTableComponent. */
+    readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
+    onRowsChange(rows: Record<string, unknown>[]): void;
+    /**
+     * Crop change: clear yield + divergence when the new crop forbids yield input,
+     * so no stale values linger under the now-disabled cells. Requirement corrections
+     * are special-crops-only (SUIBIL-1143): strip them so they never reach the emitted JSON.
+     */
+    readonly enforceArableRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
+}

package/dist/types/app/nutrient-cycle/field-cultivation/arable-land-table/arable-land-table.config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Column and section configuration for the arable-land inline table ("Grandes cultures").
+ *
+ * Replaces the former list + JSONForms detail pane for arable land: the main entry
+ * fields are edited directly in the table. The crop dropdown reuses the
+ * `agronomicCropCategoryArableLand` code list as-is, keeping its existing order.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+export declare const ARABLE_LAND_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-cultivation/crop-harvest-table/crop-harvest-table.component.d.ts

@@ -0,0 +1,21 @@
+import { FieldCultivationCropHarvest } from '../field-cultivation.types';
+import { CropHarvestTableKind } from './crop-harvest-table.config';
+/**
+ * CropHarvestTableComponent — thin wrapper around InlineTableComponent for one of the
+ * two crop-harvest tables of the "Général" tab (fed / dispensed).
+ *
+ * Rows without a selected crop (freshly added) exist only in the local `uiRows`
+ * state and are emitted upstream once a crop is picked, so no empty rows ever
+ * reach the data store (fodder `uiRows` pattern).
+ */
+export declare class CropHarvestTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FieldCultivationCropHarvest[]>;
+    readonly kind: import("@angular/core").InputSignal<CropHarvestTableKind>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldCultivationCropHarvest[]>;
+    readonly config: import("@angular/core").Signal<import("../../../components/inline-table/inline-table.types").InlineTableConfig>;
+    /** Rows as last edited locally (may contain not-yet-committed empty rows); null = follow data. */
+    private readonly uiRows;
+    readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
+    constructor();
+    onRowsChange(rows: Record<string, unknown>[]): void;
+}