@agridea/suibi-module 0.1.0-preview.5f912f0 → 0.1.0-preview.68e6607

package/dist/elements/browser/version.txt

@@ -1 +1 @@
-0.1.0-preview.5f912f0 5f912f0
+0.1.0-preview.68e6607 68e6607

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

@@ -1,3 +1,4 @@
+import { MatCheckboxChange } from '@angular/material/checkbox';
 import { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/code-lists';
 import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
 /**
@@ -62,8 +63,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 +77,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]`.
@@ -92,6 +98,10 @@ export declare class InlineTableComponent {
     onNumberChange(rowIdx: number, col: InlineColumnDef, event: Event): void;
     /** 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. */

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

@@ -11,8 +11,12 @@
  * 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. */
+export type InlineCellType = 'select' | 'number' | 'text' | 'readonly' | 'checkbox';
 /**
  * Definition for a single column in an inline table.
  *
@@ -55,6 +59,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 +92,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`).

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/utils/object.util.d.ts

@@ -22,3 +22,29 @@ export declare function deepEqual(a: unknown, b: unknown): boolean;
  * @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/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-detail.component.d.ts → farm-manure-trading-detail/farm-manure-trading-detail.component.d.ts}

@@ -1,5 +1,5 @@
 import { JsonSchema, UISchemaElement } from '@jsonforms/core';
-import { FarmManureTradingSupply, FarmManureTradingDispense } from './farm-manure-trading.types';
+import { FarmManureTradingSupply, FarmManureTradingDispense } from '../farm-manure-trading.types';
 type Mode = 'supply' | 'dispense';
 type TradingRow = FarmManureTradingSupply | FarmManureTradingDispense;
 export declare class FarmManureTradingDetailComponent {
@@ -19,7 +19,7 @@ export declare class FarmManureTradingDetailComponent {
     itemSchema: import("@angular/core").Signal<JsonSchema>;
     localizedUi: import("@angular/core").Signal<UISchemaElement>;
     detailTitle: import("@angular/core").Signal<string>;
-    jsonFormsData: import("@angular/core").Signal<(FarmManureTradingSupply & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    jsonFormsData: import("@angular/core").Signal<(FarmManureTradingSupply & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     onDataChange(event: any): void;
     private applyDerivedFields;
 }

package/dist/types/app/nutrient-cycle/farm-manure-trading/{farm-manure-trading-list.component.d.ts → farm-manure-trading-list/farm-manure-trading-list.component.d.ts}

@@ -1,5 +1,5 @@
-import { FarmManureTradingSupply, FarmManureTradingDispense } from './farm-manure-trading.types';
-import { FarmManureTradingMode } from '../../core/navigation/navigation.service';
+import { FarmManureTradingSupply, FarmManureTradingDispense } from '../farm-manure-trading.types';
+import { FarmManureTradingMode } from '../../../core/navigation/navigation.service';
 export type TradingMode = FarmManureTradingMode;
 type TradingRow = FarmManureTradingSupply | FarmManureTradingDispense;
 export declare class FarmManureTradingListComponent {

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

@@ -1,12 +1,12 @@
-import { TradingMode } from './farm-manure-trading-list.component';
-import { FarmManureTradingSupply, FarmManureTradingDispense } from './farm-manure-trading.types';
+import { TradingMode } from '../farm-manure-trading-list/farm-manure-trading-list.component';
+import { FarmManureTradingSupply, FarmManureTradingDispense } from '../farm-manure-trading.types';
 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[]>;
-    readonly activeTab: import("@angular/core").WritableSignal<import("../../core/navigation/navigation.service").FarmManureTradingMode>;
+    readonly activeTab: import("@angular/core").WritableSignal<import("../../../core/navigation/navigation.service").FarmManureTradingMode>;
     readonly selectedSupplyIndex: import("@angular/core").WritableSignal<number | null>;
     readonly selectedDispenseIndex: import("@angular/core").WritableSignal<number | null>;
     readonly currentDetail: import("@angular/core").Signal<FarmManureTradingSupply | null>;

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-list/farm-manure-trading-list.component';
+export * from './farm-manure-trading-detail/farm-manure-trading-detail.component';
+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/field-cultivation/arable-land-table/arable-land-table.component.d.ts

@@ -0,0 +1,21 @@
+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.
+     */
+    readonly enforceArableRules: (changedKey: string, newValue: unknown, row: 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;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Column and section configuration for the two crop-harvest inline tables of the
+ * "Général" tab (fed crop harvest / dispensed crop harvest).
+ *
+ * Both tables share the same columns — the same three fields the JSONForms array
+ * detail exposed before (crop, plant name, effective yield) — and differ only by
+ * their labels. The crop dropdown reuses the full `agronomicCropCategory` code
+ * list, exactly like the former JSONForms control.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+export type CropHarvestTableKind = 'feeding' | 'dispense';
+export declare const FEEDING_TABLE_CONFIG: InlineTableConfig;
+export declare const DISPENSE_TABLE_CONFIG: InlineTableConfig;

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

@@ -1,5 +1,5 @@
 import { JsonSchema, UISchemaElement } from '@jsonforms/core';
-import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from './field-cultivation.types';
+import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from '../field-cultivation.types';
 export declare class FieldCultivationDetailComponent {
     private readonly i18n;
     readonly row: import("@angular/core").InputSignal<FieldCultivationDetailEntry | null>;
@@ -17,6 +17,6 @@ export declare class FieldCultivationDetailComponent {
     readonly itemSchema: import("@angular/core").Signal<JsonSchema>;
     readonly localizedUi: import("@angular/core").Signal<UISchemaElement>;
     readonly detailTitle: import("@angular/core").Signal<string>;
-    readonly jsonFormsData: import("@angular/core").Signal<(import("./field-cultivation.types").FieldCultivationFodderCropland & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | (import("./field-cultivation.types").FieldCultivationSpecial & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    readonly jsonFormsData: import("@angular/core").Signal<(import("..").FieldCultivationSpecial & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     onDataChange(event: unknown): void;
 }

package/dist/types/app/nutrient-cycle/field-cultivation/{field-cultivation-general.component.d.ts → field-cultivation-general/field-cultivation-general.component.d.ts}

@@ -1,5 +1,5 @@
 import { JsonSchema } from '@jsonforms/core';
-import { FieldCultivationCropHarvest, FieldCultivationData } from './field-cultivation.types';
+import { FieldCultivationData } from '../field-cultivation.types';
 export declare class FieldCultivationGeneralComponent {
     private readonly i18n;
     readonly value: import("@angular/core").InputSignal<FieldCultivationData>;
@@ -15,8 +15,6 @@ export declare class FieldCultivationGeneralComponent {
         buildingZoneAreaSize: number | null | undefined;
         outdoorVegetableMainCropAreaSize: number | null | undefined;
         indoorVegetableMainCropAreaSize: number | null | undefined;
-        feedingOfCropHarvest: FieldCultivationCropHarvest[] | undefined;
-        dispenseOfCropHarvest: FieldCultivationCropHarvest[] | undefined;
-    } & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    } & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     onDataChange(event: unknown): void;
 }

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

@@ -1,4 +1,4 @@
-import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from './field-cultivation.types';
+import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from '../field-cultivation.types';
 export declare class FieldCultivationListComponent {
     private readonly masterData;
     private readonly i18n;

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation-master-detail/field-cultivation-master-detail.component.d.ts

@@ -0,0 +1,29 @@
+import { FieldCultivationTab } from '../../../core/navigation/navigation.service';
+import { CropHarvestTableKind } from '../crop-harvest-table/crop-harvest-table.config';
+import { FieldCultivationArableLand, FieldCultivationCropHarvest, FieldCultivationData, FieldCultivationFodderCropland, FieldCultivationSpecial } from '../field-cultivation.types';
+export declare class FieldCultivationMasterDetailComponent {
+    private readonly dataSvc;
+    private readonly navigationSvc;
+    constructor();
+    readonly fieldCultivation: import("@angular/core").Signal<FieldCultivationData>;
+    readonly fodderCroplandRows: import("@angular/core").Signal<FieldCultivationFodderCropland[]>;
+    readonly arableLandRows: import("@angular/core").Signal<FieldCultivationArableLand[]>;
+    readonly specialRows: import("@angular/core").Signal<FieldCultivationSpecial[]>;
+    readonly feedingRows: import("@angular/core").Signal<FieldCultivationCropHarvest[]>;
+    readonly dispenseRows: import("@angular/core").Signal<FieldCultivationCropHarvest[]>;
+    readonly activeTab: import("@angular/core").WritableSignal<FieldCultivationTab>;
+    readonly activeTabIndex: import("@angular/core").Signal<0 | 1 | 2 | 3>;
+    onTabChange(index: number): void;
+    onGeneralChange(value: FieldCultivationData): void;
+    /** Persists one crop-harvest table's rows (fed / dispensed harvests of the general tab). */
+    onCropHarvestRowsChange(kind: CropHarvestTableKind, rows: FieldCultivationCropHarvest[]): void;
+    /** Persists the fodder-cropland rows produced by the inline table (edit / add / delete). */
+    onFodderCroplandRowsChange(rows: FieldCultivationFodderCropland[]): void;
+    /** Persists the arable-land rows produced by the inline table (edit / add / delete). */
+    onArableRowsChange(rows: FieldCultivationArableLand[]): void;
+    /** Persists the special-crops rows produced by the inline table (edit / add / delete). */
+    onSpecialRowsChange(rows: FieldCultivationSpecial[]): void;
+    private patchRows;
+    private patchFieldCultivation;
+    private parseTab;
+}

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation.types.d.ts

@@ -18,6 +18,7 @@ export interface FieldCultivationBaseEntry {
 export interface FieldCultivationFodderCropland extends FieldCultivationBaseEntry {
     fieldName?: string | null;
     calculateYieldThroughFodderBalance?: boolean;
+    requirementCorrection?: FieldCultivationRequirementCorrection[];
 }
 export interface FieldCultivationArableLand extends FieldCultivationBaseEntry {
     hasLongTermYieldDivergence?: boolean;

package/dist/types/app/nutrient-cycle/field-cultivation/fodder-cropland-table/fodder-cropland-table.component.d.ts

@@ -0,0 +1,27 @@
+import { FieldCultivationFodderCropland } from '../field-cultivation.types';
+/**
+ * FodderCroplandTableComponent — thin wrapper around InlineTableComponent for the
+ * "Surface fourragère" tab: entries are edited directly in the table (no detail pane).
+ *
+ * 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). The rowTransform clears the
+ * yield whenever it is not user-editable for the row.
+ */
+export declare class FodderCroplandTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FieldCultivationFodderCropland[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldCultivationFodderCropland[]>;
+    /** Column/section config (constant — no signal needed). */
+    protected readonly config: 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;
+    /**
+     * Clears the yield whenever it stops being user-editable for the row (fodder-balance
+     * calculation switched on, or new crop without yield input), so no stale value
+     * lingers under the now-disabled cell.
+     */
+    readonly enforceFodderCroplandRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+}

package/dist/types/app/nutrient-cycle/field-cultivation/fodder-cropland-table/fodder-cropland-table.config.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Column and section configuration for the fodder-cropland inline table
+ * ("Surface fourragère" tab).
+ *
+ * Replaces the former list + JSONForms detail pane: entries are edited directly
+ * in the table. `userSpecificPlantName` and `fieldName` stay in the data model
+ * (filled by imports/API) but are no longer editable in the UI.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/**
+ * Yield is user-editable only when the selected crop permits yield input AND the
+ * yield is not calculated through the fodder balance — mirrors the former
+ * `fieldCultivation_shouldShowYieldInput` constraint of the detail form.
+ */
+export declare function yieldNotEditable(row: Record<string, unknown>): boolean;
+export declare const FODDER_CROPLAND_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-cultivation/index.d.ts

@@ -1,4 +1,9 @@
-export * from './field-cultivation-list.component';
-export * from './field-cultivation-detail.component';
-export * from './field-cultivation-master-detail.component';
+export * from './field-cultivation-list/field-cultivation-list.component';
+export * from './field-cultivation-detail/field-cultivation-detail.component';
+export * from './field-cultivation-general/field-cultivation-general.component';
+export * from './field-cultivation-master-detail/field-cultivation-master-detail.component';
+export * from './crop-harvest-table/crop-harvest-table.component';
+export * from './fodder-cropland-table/fodder-cropland-table.component';
+export * from './arable-land-table/arable-land-table.component';
+export * from './special-crops-table/special-crops-table.component';
 export * from './field-cultivation.types';

package/dist/types/app/nutrient-cycle/field-cultivation/special-crops-table/special-crops-table.component.d.ts

@@ -0,0 +1,29 @@
+import { FieldCultivationSpecial } from '../field-cultivation.types';
+/**
+ * SpecialCropsTableComponent — thin wrapper around InlineTableComponent for the
+ * "Cultures spéciales" tab: one table for the whole CULT_SPECIAL category.
+ *
+ * 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 SpecialCropsTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FieldCultivationSpecial[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldCultivationSpecial[]>;
+    /** Column/section config (constant — no signal needed). */
+    protected readonly config: 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;
+    /**
+     * Domain rules applied on every edit:
+     *  - units of the managed nutrient slots are fixed (N2 in kg, corrections in %),
+     *  - managed slots left empty are dropped (the API rejects null quantities),
+     *  - selecting a crop pre-fills Nmin from its standard N2 requirement and resets the
+     *    corrections to 100 %; clearing the crop (or picking one that forbids corrections)
+     *    removes the managed slots.
+     */
+    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+}

package/dist/types/app/nutrient-cycle/field-cultivation/special-crops-table/special-crops-table.config.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Column and section configuration for the special-crops inline table
+ * ("Cultures spéciales" tab).
+ *
+ * ONE table for the whole CULT_SPECIAL category: the crop dropdown reuses the
+ * `agronomicCropCategorySpecial` code list, which is already filtered on
+ * cultivationCategory === 'CULT_SPECIAL'. Nutrient columns live in the row's
+ * `requirementCorrection[]` sub-array: Nmin is the N2 slot in kg, the three
+ * corrections are the P2O5/K2O/Mg slots in %.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/** Nmin maps to the N2 requirement-correction slot, always expressed in kg. */
+export declare const NMIN_FORMULA = "N2";
+export declare const NMIN_UNIT = "kg";
+/** Correction slots managed by the table, always expressed in % (100 % = no correction). */
+export declare const CORRECTION_FORMULAS: readonly ["P2O5", "K2O", "Mg"];
+export declare const CORRECTION_UNIT = "%";
+export declare const CORRECTION_DEFAULT = 100;
+/** Code list feeding the crop dropdown — the whole CULT_SPECIAL category. */
+export declare const SPECIAL_CROPS_CODE_LIST = "agronomicCropCategorySpecial";
+/** Crop ids permitted in the table — every CULT_SPECIAL entry of the master data. */
+export declare const SPECIAL_CROPS_IDS: Set<string>;
+/** Looks up a crop entry in the table's code list. */
+export declare function specialCropEntry(id: unknown): Record<string, unknown> | undefined;
+/**
+ * Nutrient columns are read-only unless the selected crop has the
+ * `isPermittedForRequirementCorrection` flag: without it, the pre-filled Nmin and
+ * correction values are fixed defaults from master data and must not be user-editable.
+ */
+export declare function nutrientColumnsLocked(crop: Record<string, unknown> | undefined): boolean;
+/**
+ * Applies the crop's defaults to the requirement-correction slots.
+ * - If the crop does NOT permit requirement corrections (or none is selected): the
+ *   managed slots are removed entirely — nothing is editable and nothing is sent to the API.
+ * - If the crop DOES permit them: the managed slots are pre-filled from the crop's
+ *   master-data `requirement` (N2 in kg; P2O5/K2O/Mg in %) and stay user-editable.
+ */
+export declare function applyCropDefaults(row: Record<string, unknown>, crop: Record<string, unknown> | undefined): Record<string, unknown>;
+/**
+ * Normalizes the managed requirement-correction slots on every edit: fixed units
+ * (N2 → kg, corrections → %) and removal of managed entries left without a quantity
+ * (the API rejects present-but-null quantities).
+ */
+export declare function normalizeManagedCorrections(row: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Shared column definitions for the requirement-correction sub-array (Nmin + P2O5/K2O/Mg),
+ * reusable across fodder, arable and special tables. `lockRow` disables editing per row.
+ */
+export declare function requirementCorrectionColumns(lockRow: (row: Record<string, unknown>) => boolean): InlineTableConfig['columns'];
+/**
+ * Row-transform helper shared by fodder/arable: on every edit it normalizes the managed
+ * slots and, if the selected crop does not permit requirement corrections, strips them
+ * entirely (so nothing is sent to the API for those rows).
+ */
+export declare function stripCorrectionsUnlessPermitted(row: Record<string, unknown>, codeListKey: string): Record<string, unknown>;
+/**
+ * Row-transform helper shared by fodder/arable: on crop change it applies the crop's
+ * master-data defaults (when permitted) or strips the managed slots (when not).
+ */
+export declare function applyCropChangeRules(row: Record<string, unknown>, codeListKey: string): Record<string, unknown>;
+export declare const SPECIAL_CROPS_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-spreading/fertiliser-table/fertiliser-table.component.d.ts

@@ -23,11 +23,16 @@ export declare class FertiliserTableComponent {
     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>[]>;
-    /** Cast the generic output back to the typed FieldSpreadingFertiliserEntry[]. */
+    /** Cast the generic output back to the typed FieldSpreadingFertiliserEntry[], stripping any
+     *  ingredient with a 0 quantity so it never reaches the final JSON. */
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
      * Row transform for auto-populating nutrient columns when a product is selected.
      *
+     * Also imposes `transactionUnit = 'kg'` on every edit (not just product changes) so
+     * stale/imported rows with a different or null unit get corrected once touched —
+     * `createRow` already defaults new rows to 'kg', this is only a safety net.
+     *
      * Defined as an arrow-function property so `this` is never needed and the function
      * can be passed as a value to InlineTableComponent without losing its context.
      *

package/dist/types/app/nutrient-cycle/field-spreading/ingredient.util.d.ts

@@ -0,0 +1,8 @@
+import { FieldSpreadingIngredient } from './field-spreading.types';
+/**
+ * Ensures all ingredients are present in the output, converting `null` quantities to `0`
+ * to satisfy API requirements while still filtering out explicitly zeroed entries.
+ */
+export declare function stripZeroQuantityIngredients<T extends {
+    ingredient?: FieldSpreadingIngredient[];
+}>(entries: T[]): T[];