@agridea/suibi-module 0.1.0-preview.cf0616d → 0.1.0-preview.d54bad3

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

@@ -0,0 +1,39 @@
+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(s) — i.e. each base unit plus its
+ * custom units. Pass a nullable base (e.g. derived from a product's matterState): `null`
+ * keeps the full list (nothing derived yet); pass an array of bases (e.g. ['kg', 'm3'])
+ * to pre-filter to their union before the exact base is known.
+ *
+ * Works on any entry shape exposing `id` (and `baseUnit` for custom units).
+ */
+export declare function unitOptionsForBaseUnit<T extends {
+    id: string | number;
+}>(contextBaseUnit: string | readonly 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,25 @@ 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
+ * - `nutrientCycle.animalStock[].feeding.(winter|summer)Feeding`: never-filled routine
+ *   slots (`{}` rows pre-created by the inline tables) and null fields are dropped;
+ *   a season — and `feeding` itself — is removed when nothing filled-in remains
+ * - `nutrientCycle.fieldSpreading`: null fields dropped (`soilPh`, `slurry.*`,
+ *   `manure.*`); `slurry`/`manure` removed when nothing filled-in remains
+ */
+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/capabilities.d.ts

@@ -16,3 +16,9 @@ export declare function derivePermittedStableSystems(animalCategoryPRIF: number
  * Maps animalCategoryPRIF -> array of permitted stableSystem enum strings.
  */
 export declare const PERMITTED_STABLE_SYSTEMS: Record<number, string[]>;
+/**
+ * Pre-computed map of non-zero per-category minimum yields (yieldPerSquareMeasure).
+ * Only 8 of the 314 crop categories declare a minimum > 0 (e.g. cereals, peas);
+ * all others fall back to the schema-level `minimum: 0`.
+ */
+export declare const CROP_MINIMUM_YIELD_PER_SQUARE_MEASURE: Record<string, number>;

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

@@ -1,5 +1,5 @@
 import { ErrorObject } from 'ajv';
-import { AnimalStockCategory, FarmManureTradingCategory, FarmManureTradingMode, FieldSpreadingCategory, PageId } from '../navigation/navigation.service';
+import { AnimalStockCategory, FarmManureTradingCategory, FarmManureTradingMode, FieldCultivationTab, FieldSpreadingCategory, FodderCategory, FodderMode, PageId, StorageEntryType, StorageTab } from '../navigation/navigation.service';
 export interface EnrichedValidationError extends ErrorObject {
     /** Human-friendly field label (e.g., "Animal Category") */
     fieldLabel?: string;
@@ -17,8 +17,26 @@ export interface EnrichedValidationError extends ErrorObject {
     targetFarmManureTradingIndex?: number;
     /** Category tab inside farm manure trading detail */
     targetFarmManureTradingCategory?: FarmManureTradingCategory;
+    /** Navigation target: fodder mode */
+    targetFodderMode?: FodderMode;
+    /** Navigation target: fodder entry index */
+    targetFodderIndex?: number;
+    /** Category tab inside fodder detail */
+    targetFodderCategory?: FodderCategory;
     /** Category tab inside field spreading */
     targetFieldSpreadingCategory?: FieldSpreadingCategory;
+    /** Row index inside a field spreading tab (fertiliser/recycling) */
+    targetFieldSpreadingIndex?: number;
+    /** Category tab inside field cultivation */
+    targetFieldCultivationTab?: FieldCultivationTab;
+    /** Field cultivation detail index */
+    targetFieldCultivationIndex?: number;
+    /** Storage detail type */
+    targetStorageType?: StorageEntryType;
+    /** Storage detail index */
+    targetStorageIndex?: number;
+    /** Storage tab for list-level or scalar navigation */
+    targetStorageTab?: StorageTab;
 }
 /**
  * GlobalValidationService
@@ -37,5 +55,7 @@ export declare class GlobalValidationService {
     private inferCategory;
     private inferFarmTradingCategory;
     private inferFieldSpreadingCategory;
+    private inferFodderCategory;
+    private inferStorageTab;
     private inferFieldLabel;
 }

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

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

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

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

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

@@ -1,6 +1,8 @@
+import { Signal } from '@angular/core';
 import { JsonFormsAngularService } from '@jsonforms/angular';
 import { RankedTester } from '@jsonforms/core';
 import { BaseSelectControl } from '../../../../shared/base-control/base-select-control';
+import { SearchableSelectOption } from '../../../../shared/searchable-select/searchable-select.component';
 interface AnimalCategoryPrifEntry {
     id: number;
     animalGroup?: string;
@@ -10,12 +12,13 @@ interface AnimalCategoryPrifEntry {
     };
 }
 export declare class AnimalCategorySelectRenderer extends BaseSelectControl<number> {
-    options: AnimalCategoryPrifEntry[];
+    options: import("@angular/core").InputSignal<AnimalCategoryPrifEntry[]>;
     private readonly masterData;
     constructor(jsonFormsService: JsonFormsAngularService);
     getEventValue: (event: any) => any;
     optLabel(opt: AnimalCategoryPrifEntry): string;
-    onSelectionChange(value: number): void;
+    readonly selectOptions: Signal<SearchableSelectOption[]>;
+    onSelectionChange(value: unknown): void;
 }
 export declare const animalCategorySelectTester: RankedTester;
 export {};

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { JsonFormsBaseRenderer } from '@jsonforms/angular';
+import { GroupLayout, RankedTester } from '@jsonforms/core';
+interface ModuleCard {
+    path: string;
+    value: boolean;
+    label: string;
+    description?: string;
+}
+export declare const moduleToggleGroupTester: RankedTester;
+/**
+ * Layout renderer for `{ type: 'Group', options: { variant: 'module-toggle' } }`.
+ *
+ * Renders boolean control children as interactive card-toggles in a horizontal
+ * row. Label and description are read from the (already-localised) schema that
+ * JSONForms passes into the renderer, so no extra i18n wiring is needed here.
+ */
+export declare class ModuleToggleGroupRenderer extends JsonFormsBaseRenderer<GroupLayout> implements OnInit, OnDestroy {
+    private readonly service;
+    private readonly cdr;
+    private subscription?;
+    protected readonly _hidden: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _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. No-op while the group is disabled. */
+    toggle(dataPath: string): void;
+}
+export {};

package/dist/types/app/jsonforms/shared/searchable-select/search-highlight.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Accent- and case-insensitive matching/highlighting helpers for the searchable select.
+ * Pure functions (no DI) so matching semantics stay unit-testable without a component fixture.
+ */
+export interface HighlightSegment {
+    text: string;
+    match: boolean;
+}
+/** Folds a string for comparison: NFD decomposition + strip diacritics + lowercase. */
+export declare function normalizeForSearch(value: string): string;
+/** True when `query` (raw or normalized) is found in the label, ignoring case/accents. */
+export declare function matchesSearch(label: string, query: string): boolean;
+/**
+ * Splits `label` into segments flagging every occurrence of `normalizedQuery`.
+ * Matching runs on the normalized form but slices the original string, so accents/casing
+ * typed by the user still highlight the original characters (e.g. "mat" highlights "Mât").
+ */
+export declare function highlightSegments(label: string, normalizedQuery: string): HighlightSegment[];

package/dist/types/app/jsonforms/shared/searchable-select/searchable-select.component.d.ts

@@ -0,0 +1,63 @@
+import { FormControl } from '@angular/forms';
+import { HighlightSegment } from './search-highlight';
+export interface SearchableSelectOption<T = string | number> {
+    value: T;
+    label: string;
+}
+interface VisibleOption {
+    value: unknown;
+    segments: HighlightSegment[];
+    /** True when the option does not match the current search — kept in the DOM (hidden +
+     *  disabled) so the mat-select trigger keeps the selected option's label while typing,
+     *  and so the panel key manager natively skips it during arrow navigation. */
+    filteredOut: boolean;
+}
+/**
+ * mat-select with a sticky search field inside the panel: typing filters options and highlights
+ * the matched text (`<mark>`-style), arrows move the active (highlighted) option and Enter
+ * selects it — so the control stays fully usable with the keyboard only.
+ *
+ * Two binding modes:
+ * - reactive: pass `control` (JSONForms renderers);
+ * - plain value: pass `value` (+ `disabled`, `nullable`) — used by the inline-table cells.
+ * The panel content is duplicated in both mat-select branches on purpose: nodes rendered
+ * through a shared `<ng-template>` outlet are NOT moved into the select overlay by content
+ * projection (the anchor moves, the embedded view stays), so options/trigger would break.
+ */
+export declare class SearchableSelectComponent {
+    readonly control: import("@angular/core").InputSignal<FormControl<any> | null>;
+    readonly value: import("@angular/core").InputSignal<unknown>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly options: import("@angular/core").InputSignal<readonly SearchableSelectOption<string | number>[]>;
+    readonly label: import("@angular/core").InputSignal<string | null | undefined>;
+    readonly id: import("@angular/core").InputSignal<string>;
+    readonly multiple: import("@angular/core").InputSignal<boolean>;
+    readonly hidden: import("@angular/core").InputSignal<boolean>;
+    readonly hints: import("@angular/core").InputSignal<readonly string[]>;
+    readonly error: import("@angular/core").InputSignal<string | null | undefined>;
+    /** Adds a leading null option rendered as « – » so the selection can be cleared. */
+    readonly nullable: import("@angular/core").InputSignal<boolean>;
+    /** Table-cell density: no label, 40px container, hidden subscript wrapper. */
+    readonly compact: import("@angular/core").InputSignal<boolean>;
+    readonly selectionChange: import("@angular/core").OutputEmitterRef<unknown>;
+    private readonly i18n;
+    private readonly matSelect;
+    private readonly searchInput;
+    protected readonly query: import("@angular/core").WritableSignal<string>;
+    private readonly panelOpen;
+    protected readonly placeholderText: import("@angular/core").Signal<string>;
+    protected readonly noResultsText: import("@angular/core").Signal<string>;
+    protected readonly optionViews: import("@angular/core").Signal<VisibleOption[]>;
+    protected readonly hasVisibleOptions: import("@angular/core").Signal<boolean>;
+    constructor();
+    protected onQueryInput(event: Event): void;
+    protected onSearchKeydown(event: KeyboardEvent): void;
+    protected onOpenedChange(open: boolean): void;
+    /**
+     * mat-select keeps a stale active item when filtering shrinks the option list, which would
+     * let Enter pick an invisible option. There is no public API for this, so reach the key
+     * manager defensively and pin the highlight to the first visible match.
+     */
+    private syncActiveOption;
+}
+export {};

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

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

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

@@ -1,15 +1,12 @@
-import { EventEmitter, Signal } from '@angular/core';
-import { MatTable } from '@angular/material/table';
 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;
-    table: MatTable<AnimalStockRow>;
-    rows: Signal<AnimalStockRow[]>;
-    select: EventEmitter<number>;
-    add: EventEmitter<void>;
-    delete: EventEmitter<number>;
-    reorder: EventEmitter<{
+    rows: import("@angular/core").InputSignal<AnimalStockRow[]>;
+    select: import("@angular/core").OutputEmitterRef<number>;
+    add: import("@angular/core").OutputEmitterRef<void>;
+    delete: import("@angular/core").OutputEmitterRef<number>;
+    reorder: import("@angular/core").OutputEmitterRef<{
         previousIndex: number;
         currentIndex: number;
     }>;

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,37 @@
+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.
+     *  - no product picked yet: keep the pre-filtered unit the user chose (kg/m3/t/dt)
+     *    instead of clearing it on every edit.
+     */
+    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,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;
+}