@agridea/suibi-module 0.1.0-preview.8 → 0.1.0-preview.87cac2d

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

@@ -0,0 +1,31 @@
+export interface ManureIngredient {
+    quantity?: number;
+    molecularFormula?: string;
+    unit?: string;
+}
+export interface ManureDerivation {
+    zoologicalAnimal?: string;
+    percentageAllocation?: number;
+}
+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[];
+}
+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[];
+}
+export interface FarmManureTradingData {
+    supply?: FarmManureTradingSupply[];
+    dispense?: FarmManureTradingDispense[];
+}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +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,23 @@
+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. A crop that cannot serve
+     * as pre/catch crop forces `isMainCrop: true`. 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,16 @@
+/**
+ * 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';
+/** Looks up the row's selected crop in the arable-land code list. */
+export declare function arableCrop(row: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * Main crop is forced (checked + disabled) when the selected crop cannot serve as a
+ * pre/catch crop (`isPermittedForPreOrCatchCrop: false` in the master data).
+ */
+export declare function mainCropForced(row: Record<string, unknown>): boolean;
+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/field-cultivation-detail.component.d.ts

@@ -0,0 +1,22 @@
+import { JsonSchema, UISchemaElement } from '@jsonforms/core';
+import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from '../field-cultivation.types';
+export declare class FieldCultivationDetailComponent {
+    private readonly i18n;
+    readonly row: import("@angular/core").InputSignal<FieldCultivationDetailEntry | null>;
+    readonly index: import("@angular/core").InputSignal<number | null>;
+    readonly mode: import("@angular/core").InputSignal<FieldCultivationDetailMode>;
+    readonly rowChange: import("@angular/core").OutputEmitterRef<FieldCultivationDetailEntry>;
+    readonly close: import("@angular/core").OutputEmitterRef<void>;
+    readonly renderers: {
+        tester: import("@jsonforms/core").RankedTester;
+        renderer: any;
+    }[];
+    readonly suibiAjv: import("ajv").Ajv;
+    private readonly baseSchemas;
+    private readonly baseUis;
+    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("..").FieldCultivationSpecial & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    onDataChange(event: unknown): void;
+}

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

@@ -0,0 +1,20 @@
+import { JsonSchema } from '@jsonforms/core';
+import { FieldCultivationData } from '../field-cultivation.types';
+export declare class FieldCultivationGeneralComponent {
+    private readonly i18n;
+    readonly value: import("@angular/core").InputSignal<FieldCultivationData>;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<FieldCultivationData>;
+    readonly renderers: {
+        tester: import("@jsonforms/core").RankedTester;
+        renderer: any;
+    }[];
+    readonly ajv: import("ajv").Ajv;
+    readonly schema: import("@angular/core").Signal<JsonSchema>;
+    readonly localizedUi: import("@angular/core").Signal<import("@jsonforms/core").UISchemaElement>;
+    readonly jsonFormsData: import("@angular/core").Signal<({
+        buildingZoneAreaSize: number | null | undefined;
+        outdoorVegetableMainCropAreaSize: number | null | undefined;
+        indoorVegetableMainCropAreaSize: number | null | undefined;
+    } & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    onDataChange(event: unknown): void;
+}

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

@@ -0,0 +1,17 @@
+import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from '../field-cultivation.types';
+export declare class FieldCultivationListComponent {
+    private readonly masterData;
+    private readonly i18n;
+    readonly rows: import("@angular/core").InputSignal<FieldCultivationDetailEntry[]>;
+    readonly selectedIndex: import("@angular/core").InputSignal<number | null>;
+    readonly mode: import("@angular/core").InputSignal<FieldCultivationDetailMode>;
+    readonly select: import("@angular/core").OutputEmitterRef<number>;
+    readonly add: import("@angular/core").OutputEmitterRef<void>;
+    readonly delete: import("@angular/core").OutputEmitterRef<number>;
+    readonly displayedColumns: string[];
+    resolveCrop(code: string | null | undefined): string;
+    emptyLabel(): string;
+    emptyHintLabel(): string;
+    addLabel(): string;
+    onDelete(index: number, event: Event): void;
+}

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<1 | 0 | 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

@@ -0,0 +1,45 @@
+export interface FieldCultivationRequirementCorrection {
+    quantity?: number | null;
+    molecularFormula?: string | null;
+    unit?: string | null;
+}
+export interface FieldCultivationCropHarvest {
+    agronomicCropCategory?: string | null;
+    userSpecificPlantName?: string | null;
+    effectiveYield?: number | null;
+}
+export interface FieldCultivationBaseEntry {
+    agronomicCropCategory?: string | null;
+    userSpecificPlantName?: string | null;
+    /** Null for CSC_OUTVG special crops — the main-crop concept does not apply to them. */
+    isMainCrop?: boolean | null;
+    areaSize?: number | null;
+    /** Host-only display unit for areaSize ('m2' base, or custom e.g. 'ha') — persisted in
+     *  the dossier, converted to m2 and stripped before the planning POST (docs/custom-units.md). */
+    areaUnit?: string | null;
+    yieldPerSquareMeasure?: number | null;
+}
+export interface FieldCultivationFodderCropland extends FieldCultivationBaseEntry {
+    fieldName?: string | null;
+    calculateYieldThroughFodderBalance?: boolean;
+    requirementCorrection?: FieldCultivationRequirementCorrection[];
+}
+export interface FieldCultivationArableLand extends FieldCultivationBaseEntry {
+    hasLongTermYieldDivergence?: boolean;
+    requirementCorrection?: FieldCultivationRequirementCorrection[];
+}
+export interface FieldCultivationSpecial extends FieldCultivationBaseEntry {
+    requirementCorrection?: FieldCultivationRequirementCorrection[];
+}
+export interface FieldCultivationData {
+    buildingZoneAreaSize?: number | null;
+    outdoorVegetableMainCropAreaSize?: number | null;
+    indoorVegetableMainCropAreaSize?: number | null;
+    feedingOfCropHarvest?: FieldCultivationCropHarvest[];
+    dispenseOfCropHarvest?: FieldCultivationCropHarvest[];
+    fodderCropland?: FieldCultivationFodderCropland[];
+    arableLand?: FieldCultivationArableLand[];
+    special?: FieldCultivationSpecial[];
+}
+export type FieldCultivationDetailMode = 'fodderCropland' | 'arableLand' | 'special';
+export type FieldCultivationDetailEntry = FieldCultivationFodderCropland | FieldCultivationArableLand | FieldCultivationSpecial;

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

@@ -0,0 +1,10 @@
+import { FieldCultivationCropHarvest, FieldCultivationData, FieldCultivationDetailEntry, FieldCultivationDetailMode, FieldCultivationRequirementCorrection } from './field-cultivation.types';
+/** Subcategory whose special crops are never a main crop — `isMainCrop` must be null. */
+export declare const OUTDOOR_VEGETABLE_SUBCATEGORY = "CSC_OUTVG";
+/** True when the crop code belongs to the outdoor-vegetable subcategory (CSC_OUTVG). */
+export declare function isOutdoorVegetableCrop(cropCode: unknown): boolean;
+export declare function normalizeRequirementCorrection(source: Partial<FieldCultivationRequirementCorrection> | undefined): FieldCultivationRequirementCorrection;
+export declare function normalizeCropHarvestEntry(source: Partial<FieldCultivationCropHarvest> | undefined): FieldCultivationCropHarvest;
+export declare function normalizeFieldCultivationDetailEntry(mode: FieldCultivationDetailMode, source: Partial<FieldCultivationDetailEntry> | undefined): FieldCultivationDetailEntry;
+export declare function createEmptyFieldCultivationDetailEntry(mode: FieldCultivationDetailMode): FieldCultivationDetailEntry;
+export declare function normalizeFieldCultivation(source: Partial<FieldCultivationData> | undefined): FieldCultivationData;

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

@@ -0,0 +1,29 @@
+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. A crop that cannot serve as pre/catch crop
+     * forces `isMainCrop: true`. Requirement corrections are special-crops-only
+     * (SUIBIL-1143): strip them so they never reach the emitted JSON.
+     */
+    readonly enforceFodderCroplandRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: 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,21 @@
+/**
+ * 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;
+/**
+ * Main crop is forced (checked + disabled) when the selected crop cannot serve as a
+ * pre/catch crop (`isPermittedForPreOrCatchCrop: false` in the master data).
+ */
+export declare function mainCropForced(row: Record<string, unknown>): boolean;
+export declare const FODDER_CROPLAND_TABLE_CONFIG: InlineTableConfig;

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

@@ -0,0 +1,9 @@
+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:
+     *  - the unit of the managed nutrient slots is fixed (corrections in %),
+     *  - managed slots left empty are dropped (the API rejects null quantities),
+     *  - CSC_OUTVG crops carry `isMainCrop: null` (not a main-crop concept),
+     *  - selecting a crop pre-fills the three corrections (P2O5/K2O/Mg) at 100 %;
+     *    clearing the crop removes the managed slots.
+     */
+    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: 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,54 @@
+/**
+ * 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'. The nutrient columns are the three
+ * corrections (P2O5/K2O/Mg slots in %) living in the row's
+ * `requirementCorrection[]` sub-array.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/** 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;
+/** True when the crop cannot serve as a pre/catch crop — it must then be the main crop. */
+export declare function mainCropForced(row: Record<string, unknown>): boolean;
+/** True when the row's crop belongs to the outdoor-vegetable subcategory (CSC_OUTVG). */
+export declare function isOutdoorVegetableRow(row: Record<string, unknown>): boolean;
+/**
+ * Enforces the isMainCrop rule: null for CSC_OUTVG crops (the main-crop concept does
+ * not apply), forced to true for crops that cannot serve as pre/catch crop, restored
+ * to false when switching back to a crop where the flag applies.
+ */
+export declare function normalizeIsMainCrop(row: Record<string, unknown>): Record<string, unknown>;
+/** Corrections (P2O5/K2O/Mg) apply to every special crop; locked only without a crop. */
+export declare function correctionColumnsLocked(crop: Record<string, unknown> | undefined): boolean;
+/**
+ * Applies the crop's defaults to the requirement-correction slots:
+ * - No crop selected: the managed slots are removed entirely — nothing is editable
+ *   and nothing is sent to the API.
+ * - Crop selected: the three corrections (P2O5/K2O/Mg) are reset to 100 % 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 unit
+ * (%) 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 (P2O5/K2O/Mg),
+ * reusable across fodder, arable and special tables. `lockCorrections` disables
+ * editing per row.
+ */
+export declare function requirementCorrectionColumns(lockCorrections: (row: Record<string, unknown>) => boolean): InlineTableConfig['columns'];
+export declare const SPECIAL_CROPS_TABLE_CONFIG: InlineTableConfig;

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

@@ -0,0 +1,52 @@
+import { InlineColumnDef } from '../../../components/inline-table/inline-table.types';
+import { FieldSpreadingFertiliserEntry } from '../field-spreading.types';
+/**
+ * FertiliserTableComponent — thin wrapper around InlineTableComponent.
+ *
+ * Responsibilities:
+ *   1. Provides `FERTILISER_TABLE_CONFIG` (the column/section "uischema") to the
+ *      generic table component.
+ *   2. Bridges the typed `FieldSpreadingFertiliserEntry[]` inputs/outputs to the
+ *      generic `Record<string, unknown>[]` API expected by InlineTableComponent.
+ *   3. Supplies `autoPopulateNutrients` as a `rowTransform` — domain logic that
+ *      pre-fills Ntot/P₂O₅/K₂O/Mg from the product's max values on product selection.
+ *
+ * To create a similar table for another domain:
+ *   1. Copy `fertiliser-table.config.ts` and define new columns there.
+ *   2. Create a new thin wrapper component (like this one) that wires the config
+ *      and an optional rowTransform.
+ *   3. The generic InlineTableComponent requires no changes.
+ */
+export declare class FertiliserTableComponent {
+    private readonly i18n;
+    readonly entries: import("@angular/core").InputSignal<FieldSpreadingFertiliserEntry[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldSpreadingFertiliserEntry[]>;
+    /** Row index to highlight after a validation-error deep-link (forwarded to the table). */
+    readonly highlightRowIndex: import("@angular/core").InputSignal<number | null>;
+    /** Column/section config exposed to the template (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>[]>;
+    /** 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.
+     *
+     * Unit handling: `transactionUnit` is user-selectable between kg and its custom units
+     * (t, dt). Switching the unit converts the already-entered quantity so the amount is
+     * preserved; legacy/imported rows without a unit default to kg.
+     *
+     * 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.
+     */
+    readonly autoPopulateNutrients: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Per-cell validation for the nutrient % columns: each value capped at 100 %
+     * and the sum of the four ingredients capped at 100 % per row.
+     * The inline table bypasses JSONForms/AJV, so these rules (mirroring the
+     * `maximum` / `proportionSum` keywords in schema.json) must be surfaced
+     * visually here — the global validation panel alone is not visible while typing.
+     */
+    readonly nutrientCellError: (row: Record<string, unknown>, col: InlineColumnDef) => string | null;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Column and section configuration for the Mineral Fertiliser inline table.
+ *
+ * This is the "uischema" for the Mineral fertilisers tab — it is the ONLY file
+ * that needs to be created/modified when adapting the inline table pattern for
+ * a different domain (e.g. recycling entries).
+ *
+ * Relationship to InlineTableComponent:
+ *   - `columns` → drives header labels, cell widgets, grid widths, and code-list sources
+ *   - `createRow` → produces a blank row with the ingredient sub-array pre-initialised
+ *   - Labels reference i18n keys; chemical formula headers use `labelLiteral: true`
+ *
+ * Auto-population of nutrient columns on product selection is NOT configured here —
+ * that business logic lives in FertiliserTableComponent as a `rowTransform` function.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/** The four nutrient formulas tracked per fertiliser entry, in display order. */
+export declare const NUTRIENT_COLUMNS: readonly ["Ntot", "P2O5", "K2O", "Mg"];
+export type NutrientFormula = (typeof NUTRIENT_COLUMNS)[number];
+export declare const FERTILISER_TABLE_CONFIG: InlineTableConfig;

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

@@ -0,0 +1,36 @@
+import { JsonSchema } from '@jsonforms/core';
+import { FieldSpreadingData, FieldSpreadingFertiliserEntry, FieldSpreadingRecyclingEntry } from './field-spreading.types';
+export declare class FieldSpreadingComponent {
+    private readonly dataSvc;
+    private readonly navigationSvc;
+    private readonly i18n;
+    constructor();
+    /** Fertiliser row to highlight (set by validation deep-links, cleared by the next one). */
+    readonly highlightedFertiliserIndex: import("@angular/core").WritableSignal<number | null>;
+    readonly schema: import("@angular/core").Signal<JsonSchema>;
+    readonly localizedGeneralUi: import("@angular/core").Signal<import("@jsonforms/core").UISchemaElement>;
+    readonly renderers: {
+        tester: import("@jsonforms/core").RankedTester;
+        renderer: any;
+    }[];
+    readonly ajv: import("ajv").Ajv;
+    private readonly normalizedFieldSpreading;
+    readonly jsonFormsData: import("@angular/core").Signal<(FieldSpreadingData & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    /** Fertiliser entries exposed to the custom table component. */
+    readonly fertiliserEntries: import("@angular/core").Signal<FieldSpreadingFertiliserEntry[]>;
+    /** Recycling entries exposed to the custom table component. */
+    readonly recyclingEntries: import("@angular/core").Signal<FieldSpreadingRecyclingEntry[]>;
+    /** Drives mat-tab-group [selectedIndex] from NavigationService state. */
+    readonly activeTabIndex: import("@angular/core").Signal<number>;
+    onTabChange(index: number): void;
+    /** Called by both general JSONForms instances on data change.
+     *  Preserves fertiliser and recycling entries managed by their custom table components. */
+    onDataChange(event: unknown): void;
+    /** Called by FertiliserTableComponent when entries are added/edited/removed. */
+    onFertiliserChange(fertiliser: FieldSpreadingFertiliserEntry[]): void;
+    /** Called by RecyclingTableComponent when entries are added/edited/removed. */
+    onRecyclingChange(recycling: FieldSpreadingRecyclingEntry[]): void;
+    private patchFieldSpreading;
+    private normalizeFieldSpreading;
+    private areFieldSpreadingEqual;
+}

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

@@ -0,0 +1,44 @@
+export interface FieldSpreadingOtherApplicationTechnology {
+    applicationTechnologyType?: number | null;
+    proportionOfArea?: number | null;
+}
+export interface FieldSpreadingSlurry {
+    quantity?: number | null;
+    dilutionRatio?: number | null;
+    applicationDuringWarmDays?: number | null;
+    proportionAppliedSummerMonths?: number | null;
+    proportionAppliedOtherMonths?: number | null;
+    proportionAppliedAfter6PM?: number | null;
+    dragHoseAreaSize?: number | null;
+    otherApplicationTechnologies?: FieldSpreadingOtherApplicationTechnology[];
+}
+export interface FieldSpreadingManure {
+    applicationIncorporationTime?: number | null;
+    proportionAppliedSummerMonths?: number | null;
+    proportionAppliedOtherMonths?: number | null;
+}
+export interface FieldSpreadingIngredient {
+    molecularFormula?: string | null;
+    quantity?: number | null;
+    unit?: string | null;
+}
+export interface FieldSpreadingFertiliserEntry {
+    descriptor?: string | null;
+    fertiliserProductCategory?: string | null;
+    quantity?: number | null;
+    transactionUnit?: string | null;
+    ingredient?: FieldSpreadingIngredient[];
+}
+export interface FieldSpreadingRecyclingEntry {
+    typeOfManureRecyclingProduct?: string | null;
+    quantity?: number | null;
+    transactionUnit?: string | null;
+    ingredient?: FieldSpreadingIngredient[];
+}
+export interface FieldSpreadingData {
+    soilPh?: number | null;
+    slurry?: FieldSpreadingSlurry;
+    manure?: FieldSpreadingManure;
+    fertiliser?: FieldSpreadingFertiliserEntry[];
+    recycling?: FieldSpreadingRecyclingEntry[];
+}

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

@@ -0,0 +1,2 @@
+export * from './field-spreading.component';
+export * from './field-spreading.types';

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[];