@agridea/suibi-module 0.1.0-preview.9d0dbe2 → 0.1.0-preview.a4b0024

package/dist/elements/browser/version.txt

@@ -1 +1 @@
-0.1.0-preview.9d0dbe2 9d0dbe2
+0.1.0-preview.a4b0024 a4b0024

package/dist/elements/browser/wc-global-utilities.css

@@ -1 +1 @@
-.cdk-overlay-container{position:fixed;inset:0;z-index:1200;pointer-events:none}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{position:fixed;inset:0;display:flex;align-items:flex-start;justify-content:center;pointer-events:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1200;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1200}.cdk-overlay-backdrop{position:fixed;inset:0;z-index:1199;pointer-events:auto}.cdk-overlay-transparent-backdrop{background:transparent}.cdk-overlay-dark-backdrop{background:#00000052}.mat-mdc-select-panel.mdc-menu-surface{background:#fff;--mdc-theme-surface: #fff;--mdc-menu-container-color: #fff;--mat-select-panel-background-color: #fff;box-shadow:0 4px 16px #00000040;border-radius:4px;outline:0;opacity:1!important;filter:none!important}
+.cdk-overlay-container{position:fixed;inset:0;z-index:1200;pointer-events:none}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{position:fixed;inset:0;display:flex;align-items:flex-start;justify-content:center;pointer-events:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1200;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1200}.cdk-overlay-backdrop{position:fixed;inset:0;z-index:1199;pointer-events:auto}.cdk-overlay-transparent-backdrop{background:transparent}.cdk-overlay-dark-backdrop{background:#00000052}.mat-mdc-select-panel.mdc-menu-surface{background:#fff;--mdc-theme-surface: #fff;--mdc-menu-container-color: #fff;--mat-select-panel-background-color: #fff;box-shadow:0 4px 16px #00000040;border-radius:4px;outline:0;opacity:1!important;filter:none!important}.mat-mdc-option.mdc-list-item{height:auto;min-height:48px}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;overflow:visible;text-overflow:clip;line-height:1.35}

package/dist/types/app/components/data-preview/data-preview.component.d.ts

@@ -3,9 +3,231 @@ import { PlanningBalanceService } from '../../core/planning/planning-balance.ser
 export declare class DataPreviewComponent {
     private readonly host;
     private readonly emitter;
+    private readonly clipboard;
     readonly planning: PlanningBalanceService;
     readonly naebi: NaebiDataService;
     readonly metadataPreview: import("@angular/core").Signal<import("../../../public-api").SuibiDataEventMetadata>;
+    /** Exact payload that runPlanning will POST (same builder as the real request). */
+    readonly apiPayload: import("@angular/core").Signal<{
+        nutrientCycle: {
+            animalStock: {
+                order: string;
+                animalCategoryPRIF: number;
+                selfReportedLivestock: {
+                    averageQuantity: number;
+                };
+                durationCorrectionQuantity: number;
+                durationCorrectionDays: number;
+                utilisation: number;
+                formOfDetention: {
+                    hasGrazing: boolean;
+                    pasture: {
+                        days: number;
+                        hoursPerDay: number;
+                    };
+                    stall: {
+                        stableSystem: string;
+                        stableVentilationType: number;
+                        hasStableDeepLitter: boolean;
+                        hasStableManureBeltDrying: boolean;
+                        stableManureRemovalFrequency: number;
+                        stableWaterSupply: number;
+                        hasStableManureAndSlurryProduction: boolean;
+                        hasStableFeedingStationElevated: boolean;
+                        hasStableFloorSlopedUrineDrainage: boolean;
+                        hasYard: boolean;
+                    };
+                };
+                hasImpexDerivedExcretion: boolean;
+                hasLinearCorrectionDerivedExcretion: boolean;
+                feeding: {
+                    fodderConsumption: number;
+                    concentratedFeedstuffConsumption: number;
+                    concentratedFeedStuffConsumption: number;
+                    winterFeeding: {
+                        feedingRoutine: {
+                            typeOfFeedstuffProduct: string;
+                            transactionUnit: string;
+                            quantity: number;
+                        }[];
+                        dailyConcentratedFeedstuff: {
+                            quantity: number;
+                        };
+                    };
+                    summerFeeding: {
+                        feedingRoutine: {
+                            typeOfFeedstuffProduct: string;
+                            transactionUnit: string;
+                            quantity: number;
+                        }[];
+                        dailyConcentratedFeedstuff: {
+                            quantity: number;
+                        };
+                    };
+                };
+            }[];
+            storage: {
+                stableStrawLitter: number;
+                slurrySupplyProportionStored: number;
+                createFacilitySpecificManureProduct: boolean;
+                createFacilitySpecificSlurryProduct: boolean;
+                slurryTankQuantity: number;
+                dilutionRatio: number;
+                manurePit: never[];
+                slurryTank: {
+                    descriptor: string;
+                    volumeInM3: number;
+                    depthInM: number;
+                    cover: number;
+                    mixingFrequency: number;
+                    manureDerivation: string[];
+                }[];
+            };
+            farmManureTrading: {
+                supply: never[];
+                dispense: {
+                    quantity: number;
+                    typeOfManureRecyclingProduct: string;
+                    transactionUnit: string;
+                    manureDerivation: {
+                        zoologicalAnimal: string;
+                        percentageAllocation: number;
+                    }[];
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            fieldSpreading: {
+                soilPh: number;
+                slurry: {
+                    quantity: number;
+                    dilutionRatio: number;
+                    otherApplicationTechnologies: {
+                        applicationTechnologyType: number;
+                        proportionOfArea: number;
+                    }[];
+                    applicationDuringWarmDays: number;
+                    proportionAppliedSummerMonths: number;
+                    proportionAppliedOtherMonths: number;
+                    proportionAppliedAfter6PM: number;
+                    dragHoseAreaSize: number;
+                };
+                manure: {
+                    applicationIncorporationTime: number;
+                    proportionAppliedSummerMonths: number;
+                    proportionAppliedOtherMonths: number;
+                };
+                fertiliser: {
+                    descriptor: string;
+                    fertiliserProductCategory: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        molecularFormula: string;
+                        quantity: number;
+                        unit: string;
+                    }[];
+                }[];
+                recycling: {
+                    typeOfManureRecyclingProduct: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        molecularFormula: string;
+                        quantity: number;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            lifetimePerformance: {
+                milkProductionReport: number;
+            };
+            fodder: {
+                trading: {
+                    supply: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: {
+                            quantity: number;
+                            molecularFormula: string;
+                            unit: string;
+                        }[];
+                    }[];
+                    dispense: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: never[];
+                    }[];
+                };
+                cropFromNonFodderCropland: {
+                    typeOfFeedstuffProduct: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+                proportionStorageLoss: number;
+                totalBalanceErrorMargin: number;
+            };
+            fieldCultivation: {
+                buildingZoneAreaSize: number;
+                outdoorVegetableMainCropAreaSize: number;
+                indoorVegetableMainCropAreaSize: number;
+                feedingOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                dispenseOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                fodderCropland: ({
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    calculateYieldThroughFodderBalance: boolean;
+                    yieldPerSquareMeasure?: undefined;
+                } | {
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    yieldPerSquareMeasure: number;
+                    calculateYieldThroughFodderBalance?: undefined;
+                })[];
+                arableLand: {
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    yieldPerSquareMeasure: number;
+                    hasLongTermYieldDivergence: boolean;
+                }[];
+                special: {
+                    agronomicCropCategory: string;
+                    userSpecificPlantName: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    requirementCorrection: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            generateReport: boolean;
+        };
+        calculationVersion: {
+            version: string;
+        };
+    }>;
     setPlanningEndpoint(value: string | null): void;
     emitData(): void;
+    copyJson(getValue: () => unknown): void;
 }

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

@@ -33,6 +33,12 @@ export declare class PlanningBalanceService {
     };
     readonly selectedEndpoint: import("@angular/core").Signal<PlanningEndpoint>;
     setSelectedEndpoint(endpoint: PlanningEndpoint): void;
+    /**
+     * Builds the exact payload posted to the planning API: calculationVersion stamped from
+     * the current metadata, empty ingredient/routine slots stripped, null optional fields
+     * and host-only fields removed, custom display units converted to base units.
+     */
+    buildApiPayload(data: NaebiData): NaebiData;
     /** Fire a new planning-balance request with the current NAEBI data payload. */
     runPlanning(data: NaebiData, endpoint?: PlanningEndpoint): void;
 }

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

@@ -1,5 +1,5 @@
 export interface CustomUnit {
-    /** Unit code stored on the row (e.g. 'ha', 't', 'kt'). */
+    /** 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;
@@ -13,15 +13,26 @@ 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, kt]). */
+/** Custom units convertible to the given base unit (e.g. 'kg' → [t, dt]). */
 export declare function customUnitsForBaseUnit(baseUnit: string): CustomUnit[];
+/**
+ * Builds a filter (compatible with the inline table's `optionsFilter`) keeping only the
+ * units compatible with the given context base unit — i.e. the base unit itself plus its
+ * custom units. Pass a nullable base (e.g. derived from a product's matterState): `null`
+ * keeps the full list (nothing derived yet).
+ *
+ * Works on any entry shape exposing `id` (and `baseUnit` for custom units).
+ */
+export declare function unitOptionsForBaseUnit<T extends {
+    id: string | number;
+}>(contextBaseUnit: string | null | undefined): (entry: T) => boolean;
 /** Converts a quantity expressed in a custom unit to its base unit; pass-through for
  *  base/unknown units and null quantities. */
 export declare function convertToBaseUnit(quantity: number | null | undefined, unit: string | null | undefined): {
     quantity: number | null | undefined;
     unit: string | null | undefined;
 };
-/** Converts a quantity between two units sharing the same base unit (kg ↔ t ↔ kt,
+/** 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

@@ -34,6 +34,11 @@ export declare function stripIncompleteIngredients<T>(value: T): T;
  *   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). */

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

@@ -12,7 +12,7 @@ type TradingRow = FarmManureTradingSupply | FarmManureTradingDispense;
  *   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, kt for kg), which converts the entered quantity on the fly.
+ *      (t, dt for kg), which converts the entered quantity on the fly.
  */
 export declare class FarmManureTradingTableComponent {
     readonly mode: import("@angular/core").InputSignal<FarmManureTradingMode>;

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

@@ -6,4 +6,6 @@
  * `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;
 export declare const ARABLE_LAND_TABLE_CONFIG: InlineTableConfig;

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

@@ -11,7 +11,8 @@ export interface FieldCultivationCropHarvest {
 export interface FieldCultivationBaseEntry {
     agronomicCropCategory?: string | null;
     userSpecificPlantName?: string | null;
-    isMainCrop?: boolean;
+    /** 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). */

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

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

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

@@ -19,11 +19,11 @@ export declare class SpecialCropsTableComponent {
     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 %),
+     *  - the unit of the managed nutrient slots is fixed (corrections in %),
      *  - managed slots left empty are dropped (the API rejects null quantities),
-     *  - selecting a crop pre-fills the nutrient slots per its cultivationSubCategory
-     *    (Gemüse: Nmin from the standard N2 requirement + corrections reset to 100 %;
-     *    Dauerkulturen: corrections only); clearing the crop removes the managed slots.
+     *  - 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

@@ -4,19 +4,11 @@
  *
  * 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 %.
- *
- * Which nutrient columns apply depends on the selected crop's
- * cultivationSubCategory (NäBIS backend rule): Gemüse (CSC_PRCRP, CSC_OUTVG)
- * get Nmin + P/K/Mg; Dauerkulturen (CSC_DIVCR, CSC_ECOBL, CSC_PRMCR) get only
- * P/K/Mg — no Nmin.
+ * 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';
-/** 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 = "%";
@@ -27,35 +19,33 @@ export declare const SPECIAL_CROPS_CODE_LIST = "agronomicCropCategorySpecial";
 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;
-/** CULT_SPECIAL sub-categories "Gemüse" — Nmin + P/K/Mg corrections apply. */
-export declare const VEGETABLE_SUBCATEGORIES: ReadonlySet<string>;
-/** CULT_SPECIAL sub-categories "Dauerkulturen" — only P/K/Mg corrections apply (no Nmin). */
-export declare const PERMANENT_SUBCATEGORIES: ReadonlySet<string>;
-/** Nmin is editable only for vegetable special crops (Gemüse: CSC_PRCRP/CSC_OUTVG). */
-export declare function nminColumnLocked(crop: Record<string, unknown> | undefined): 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), 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, driven by the
- * crop's cultivationSubCategory:
+ * 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.
- * - Gemüse (CSC_PRCRP/CSC_OUTVG): Nmin pre-filled from the crop's master-data N2
- *   requirement (kg) and the three corrections reset to 100 %, all user-editable.
- * - Dauerkulturen (CSC_DIVCR/CSC_ECOBL/CSC_PRMCR): only the three corrections,
- *   reset to 100 % — no Nmin slot.
+ * - 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 units
- * (N2 → kg, corrections → %) and removal of managed entries left without a quantity
- * (the API rejects present-but-null quantities).
+ * 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 (Nmin + P2O5/K2O/Mg),
- * reusable across fodder, arable and special tables. `lockNmin` / `lockCorrections`
- * disable editing per row.
+ * 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(lockNmin: (row: Record<string, unknown>) => boolean, lockCorrections: (row: Record<string, unknown>) => boolean): InlineTableConfig['columns'];
+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

@@ -34,7 +34,7 @@ export declare class FertiliserTableComponent {
      * 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, kt). Switching the unit converts the already-entered quantity so the amount is
+     * (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

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

@@ -9,7 +9,7 @@ import { FieldSpreadingRecyclingEntry } from '../field-spreading.types';
  *   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, kt for kg), which converts the entered quantity on the fly.
+ *      (t, dt for kg), which converts the entered quantity on the fly.
  */
 export declare class RecyclingTableComponent {
     readonly entries: import("@angular/core").InputSignal<FieldSpreadingRecyclingEntry[]>;

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

@@ -19,7 +19,7 @@ export declare class FodderTableComponent {
      *    when it is not permitted for the new kind.
      *  - Product change: pre-fill the dry matter share (T/S %) with the product's
      *    `standardDryMatterContent` (stays editable afterwards; null when none is defined).
-     *  - `transactionUnit` is selectable between kg and its custom units (t, kt): switching
+     *  - `transactionUnit` is selectable between kg and its custom units (t, dt): switching
      *    converts the entered quantity so the amount is preserved; rows without a unit
      *    default to kg. The only permitted ingredient is dry matter (T/S) in % — re-appended
      *    when missing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agridea/suibi-module",
-  "version": "0.1.0-preview.9d0dbe2",
+  "version": "0.1.0-preview.a4b0024",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",