@agridea/suibi-module 0.1.0-preview.8 → 0.1.0-preview.82d9ee0

package/dist/types/app/core/data/naebi-data.service.d.ts

@@ -1,5 +1,7 @@
-import naebiExample from '../../../../assets/example-data/example-naebi-data.json';
-export type NaebiData = typeof naebiExample;
+import exampleDetail from '../../../../assets/example-data/example-naebi-data.json';
+type SampleEvent = typeof exampleDetail;
+type SampleData = SampleEvent['payload']['data'];
+export type NaebiData = SampleData;
 /**
  * Calculation mode determines which validation rules and features are active.
  */
@@ -27,10 +29,8 @@ export declare class NaebiDataService {
                         hoursPerDay: number;
                     };
                     stall: {
-                        stableSystem: number;
-                        stableCapacity: number;
+                        stableSystem: string;
                         stableVentilationType: number;
-                        stableAirPurification: number;
                         hasStableDeepLitter: boolean;
                         hasStableManureBeltDrying: boolean;
                         stableManureRemovalFrequency: number;
@@ -39,10 +39,6 @@ export declare class NaebiDataService {
                         hasStableFeedingStationElevated: boolean;
                         hasStableFloorSlopedUrineDrainage: boolean;
                         hasYard: boolean;
-                        yardFeeding: number;
-                        yardFloorType: number;
-                        yardDays: number;
-                        yardHoursPerDay: number;
                     };
                 };
                 hasImpexDerivedExcretion: boolean;
@@ -50,6 +46,7 @@ export declare class NaebiDataService {
                 feeding: {
                     fodderConsumption: number;
                     concentratedFeedstuffConsumption: number;
+                    concentratedFeedStuffConsumption: number;
                     winterFeeding: {
                         feedingRoutine: {
                             typeOfFeedstuffProduct: string;
@@ -74,19 +71,14 @@ export declare class NaebiDataService {
             }[];
             storage: {
                 stableStrawLitter: number;
-                manureSupplyProportionStored: number;
                 slurrySupplyProportionStored: number;
                 createFacilitySpecificManureProduct: boolean;
                 createFacilitySpecificSlurryProduct: boolean;
+                slurryTankQuantity: number;
                 dilutionRatio: number;
-                manurePit: {
-                    cover: number;
-                    manureFromAnimalStockStored: {
-                        manureDerivation: string;
-                        proportionStored: number;
-                    }[];
-                }[];
+                manurePit: never[];
                 slurryTank: {
+                    descriptor: string;
                     volumeInM3: number;
                     depthInM: number;
                     cover: number;
@@ -95,16 +87,7 @@ export declare class NaebiDataService {
                 }[];
             };
             farmManureTrading: {
-                supply: {
-                    quantity: number;
-                    typeOfManureRecyclingProduct: string;
-                    transactionUnit: string;
-                    ingredient: {
-                        quantity: number;
-                        molecularFormula: string;
-                        unit: string;
-                    }[];
-                }[];
+                supply: never[];
                 dispense: {
                     quantity: number;
                     typeOfManureRecyclingProduct: string;
@@ -113,6 +96,11 @@ export declare class NaebiDataService {
                         zoologicalAnimal: string;
                         percentageAllocation: number;
                     }[];
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
                 }[];
             };
             fieldSpreading: {
@@ -125,14 +113,18 @@ export declare class NaebiDataService {
                         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;
@@ -154,8 +146,6 @@ export declare class NaebiDataService {
                 }[];
             };
             lifetimePerformance: {
-                dailyGain: number;
-                liveWeight: number;
                 milkProductionReport: number;
             };
             fodder: {
@@ -170,6 +160,12 @@ export declare class NaebiDataService {
                             unit: string;
                         }[];
                     }[];
+                    dispense: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: never[];
+                    }[];
                 };
                 cropFromNonFodderCropland: {
                     typeOfFeedstuffProduct: string;
@@ -185,6 +181,17 @@ export declare class NaebiDataService {
                 totalBalanceErrorMargin: number;
             };
             fieldCultivation: {
+                buildingZoneAreaSize: number;
+                outdoorVegetableMainCropAreaSize: number;
+                indoorVegetableMainCropAreaSize: number;
+                feedingOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                dispenseOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
                 fodderCropland: ({
                     agronomicCropCategory: string;
                     isMainCrop: boolean;
@@ -203,25 +210,38 @@ export declare class NaebiDataService {
                     isMainCrop: boolean;
                     areaSize: number;
                     yieldPerSquareMeasure: number;
+                    hasLongTermYieldDivergence: boolean;
                 }[];
                 special: {
                     agronomicCropCategory: string;
                     userSpecificPlantName: string;
                     isMainCrop: boolean;
                     areaSize: number;
-                    yieldPerSquareMeasure: number;
+                    requirementCorrection: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
                 }[];
             };
             generateReport: boolean;
         };
+        calculationVersion: {
+            version: string;
+        };
     }>;
+    private readonly _lastEmitted;
+    private readonly _dirty;
+    readonly dirty: import("@angular/core").Signal<boolean>;
     private readonly _calculationMode;
     readonly calculationMode: import("@angular/core").Signal<CalculationMode>;
     /**
      * Set new data value; accepts plain object (already parsed) matching NaebiData shape.
-     * Silent no-op if value is structurally equal reference to avoid unnecessary updates (cheap ref check only).
+     * Silent no-op if value is structurally equal after normalization to avoid unnecessary updates.
      */
     setData(value: NaebiData): void;
+    /** Mark current data as saved (clears dirty state and updates snapshot). */
+    markSaved(): void;
     /**
      * Set calculation mode (SuiBi or ExBi).
      * Can affect which validation rules are active or which features are enabled.
@@ -230,3 +250,4 @@ export declare class NaebiDataService {
     /** Reset to bundled example */
     reset(): void;
 }
+export {};

package/dist/types/app/core/error/global-error-handler.d.ts

@@ -0,0 +1,5 @@
+import { ErrorHandler } from '@angular/core';
+export declare class GlobalErrorHandler implements ErrorHandler {
+    private readonly injector;
+    handleError(error: any): void;
+}

package/dist/types/app/core/events/suibi-data-emitter.service.d.ts

@@ -0,0 +1,13 @@
+import { SuibiDataEventDetail, SuibiDataEventMetadata } from './suibi-data-event';
+/**
+ * Centralizes construction + dispatch of the `suibi-data-emitted` payload so multiple UI entry points can reuse it.
+ */
+export declare class SuibiDataEmitterService {
+    private readonly i18n;
+    private readonly validation;
+    private readonly metadataSvc;
+    private readonly naebi;
+    buildMetadata(): SuibiDataEventMetadata;
+    buildDetail(): SuibiDataEventDetail;
+    emitFrom(target: HTMLElement): void;
+}

package/dist/types/app/core/events/suibi-data-event.d.ts

@@ -0,0 +1,26 @@
+import { Locale } from '../i18n/i18n.service';
+import { NaebiData } from '../data/naebi-data.service';
+import { SuibiMetadata } from '../metadata/suibi-metadata.types';
+/**
+ * Increment when the payload contract changes in a backwards-incompatible way.
+ */
+export declare const SUIBI_DATA_EVENT_VERSION = "suibi-data.v1";
+/** Detail object emitted with the `suibi-data` CustomEvent. */
+export interface SuibiDataEventDetail {
+    version: typeof SUIBI_DATA_EVENT_VERSION;
+    payload: SuibiDataEventPayload;
+}
+/** Top-level payload structure delivered to host applications. */
+export interface SuibiDataEventPayload {
+    metadata: SuibiDataEventMetadata;
+    data: NaebiData;
+}
+/**
+ * Metadata describing the dataset at the moment of emission so hosts can audit and reason about it.
+ */
+export type SuibiDataEventMetadata = SuibiMetadata & {
+    emittedAt: string;
+    locale: Locale;
+    isValid: boolean;
+    errorCount: number;
+};

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

@@ -1,5 +1,5 @@
 import { PipeTransform, Signal } from '@angular/core';
-export type Locale = 'en' | 'de';
+export type Locale = 'en' | 'de' | 'fr' | 'it';
 export type JsonFormsTranslator = (key: string, defaultMessage: string | undefined, context: unknown) => string;
 export declare class I18nService {
     private readonly _locale;
@@ -8,13 +8,15 @@ export declare class I18nService {
     readonly jsonFormsI18n: Signal<{
         locale: Locale;
         translate: JsonFormsTranslator;
+        translateError: (error: unknown, translate: JsonFormsTranslator) => string;
     }>;
     setLocale(locale: Locale): void;
+    /** Returns true if the given string is a supported locale key. */
+    isValidLocale(value: string): value is Locale;
     t(key: string, defaultMessage?: string): string;
 }
 export declare class TranslatePipe implements PipeTransform {
-    private readonly i18n;
     private readonly cache;
-    constructor(i18n: I18nService);
+    private readonly i18n;
     transform(key: string, defaultMessage?: string): Signal<string>;
 }

package/dist/types/app/core/i18n/locales/fr.d.ts

@@ -0,0 +1,2 @@
+export declare const frTranslations: Record<string, string>;
+export type FrTranslationKeys = keyof typeof frTranslations;

package/dist/types/app/core/i18n/locales/it.d.ts

@@ -0,0 +1,2 @@
+export declare const itTranslations: Record<string, string>;
+export type ItTranslationKeys = keyof typeof itTranslations;

package/dist/types/app/core/master-data/master-data.service.d.ts

@@ -1,5 +1,12 @@
 import { Locale } from '../i18n/i18n.service';
-declare const MASTER_DATA: Record<string, any[]>;
+/** The property name of the primary key in a master-data catalog entry. */
+type MasterDataKeyField = string;
+interface MasterDataCatalog {
+    entries: any[];
+    /** Property name to use as the lookup key; 'id' entries are coerced to Number. */
+    key: MasterDataKeyField;
+}
+declare const MASTER_DATA: Record<string, MasterDataCatalog>;
 export type MasterDataKind = keyof typeof MASTER_DATA;
 export declare class MasterDataService {
     private readonly i18n;
@@ -14,5 +21,12 @@ export declare class MasterDataService {
     designation(kind: MasterDataKind, id: number | string | null | undefined, locale?: Locale): string;
     resolveAnimalCategory(id: number | string | null | undefined, locale?: Locale): string;
     resolveUtilisation(id: number | string | null | undefined, locale?: Locale): string;
+    resolveManureProduct(code: string | null | undefined, locale?: Locale): string;
+    resolveZoologicalAnimal(code: string | null | undefined, locale?: Locale): string;
+    resolveCultivationCategory(code: string | null | undefined, locale?: Locale): string;
+    resolveAgronomicCropCategory(code: string | null | undefined, locale?: Locale): string;
+    resolveFeedstuffProduct(code: string | null | undefined, locale?: Locale): string;
+    resolveCover(id: number | string | null | undefined, locale?: Locale): string;
+    resolveMixingFrequency(id: number | string | null | undefined, locale?: Locale): string;
 }
 export {};

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

@@ -0,0 +1,6 @@
+import { SuibiMetadata } from './suibi-metadata.types';
+export declare class SuibiMetadataService {
+    private readonly metadataSignal;
+    readonly metadata: import("@angular/core").Signal<SuibiMetadata>;
+    setMetadata(next: SuibiMetadata): void;
+}

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

@@ -0,0 +1,18 @@
+export type SuibiVersion = 'v2.0';
+export type SubmissionStatus = 'draft' | 'submitted' | 'final';
+/** Which computation modules are active for this dossier. */
+export interface ComputationModules {
+    suisseBilanz: boolean;
+    gmf: boolean;
+    nh3: boolean;
+    impex: boolean;
+    linear: boolean;
+}
+export declare const DEFAULT_COMPUTATION_MODULES: ComputationModules;
+export interface SuibiMetadata {
+    title: string;
+    suibiVersion: SuibiVersion;
+    status: SubmissionStatus;
+    modules: ComputationModules;
+}
+export declare const DEFAULT_SUIBI_METADATA: SuibiMetadata;

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

@@ -1,5 +1,13 @@
-export type PageId = 'welcome' | 'animal_stock' | 'data_preview' | 'storage' | 'field_spreading' | 'farm_manure_trading';
+export type PageId = 'welcome' | 'animal_stock' | 'data_preview' | 'storage' | 'field_spreading' | 'farm_manure_trading' | 'fodder' | 'field_cultivation' | 'validation' | 'results';
 export type AnimalStockCategory = 'base' | 'formOfDetention' | 'feeding';
+export type FarmManureTradingMode = 'supply' | 'dispense';
+export type FarmManureTradingCategory = 'general' | 'derivation' | 'ingredients';
+export type FodderMode = 'supply' | 'dispense' | 'non_fodder_cropland';
+export type FodderCategory = 'general' | 'ingredients';
+export type FieldSpreadingCategory = 'general' | 'fertiliser' | 'recycling';
+export type FieldCultivationTab = 'general' | 'fodderCropland' | 'arableLand' | 'special';
+export type StorageTab = 'manure' | 'slurry';
+export type StorageEntryType = 'manure_pit' | 'slurry_tank';
 /**
  * NavigationService
  * Global reactive store for application routing and deep-link state.
@@ -21,8 +29,40 @@ export declare class NavigationService {
     readonly currentPage: import("@angular/core").WritableSignal<PageId>;
     /** Selected animal stock entry index (null = list view) */
     readonly selectedAnimalStockIndex: import("@angular/core").WritableSignal<number | null>;
-    /** Selected category (tab) within animal stock detail */
-    readonly selectedAnimalStockCategory: import("@angular/core").WritableSignal<AnimalStockCategory>;
+    /**
+     * Generic category (tab) selection: stores current page + selected category key.
+     * Used by categorization renderer for programmatic tab control.
+     * Format: { page: PageId, category: string }
+     */
+    readonly selectedCategory: import("@angular/core").WritableSignal<{
+        page: PageId;
+        category: string;
+    }>;
+    /** Selected farm manure trading detail context (mode + index) */
+    readonly selectedFarmManureTrading: import("@angular/core").WritableSignal<{
+        mode: FarmManureTradingMode;
+        index: number;
+    } | null>;
+    /** Selected fodder detail context (mode + index) */
+    readonly selectedFodderDetail: import("@angular/core").WritableSignal<{
+        mode: FodderMode;
+        index: number;
+    } | null>;
+    /** Selected field cultivation detail context (tab + index) */
+    readonly selectedFieldCultivationDetail: import("@angular/core").WritableSignal<{
+        tab: Exclude<FieldCultivationTab, "general">;
+        index: number;
+    } | null>;
+    /** Selected storage detail context (type + index) */
+    readonly selectedStorageDetail: import("@angular/core").WritableSignal<{
+        type: StorageEntryType;
+        index: number;
+    } | null>;
+    /** Selected field spreading row context (category/tab + row index) — used by validation deep-links */
+    readonly selectedFieldSpreadingDetail: import("@angular/core").WritableSignal<{
+        category: FieldSpreadingCategory;
+        index: number;
+    } | null>;
     /** True if currently viewing animal stock detail (not list) */
     readonly isAnimalStockDetailView: import("@angular/core").Signal<boolean>;
     /** True if currently on animal stock page (list or detail) */
@@ -41,10 +81,24 @@ export declare class NavigationService {
      * Used by validation error navigation and internal routing.
      */
     navigateToAnimalStockDetail(index: number, category?: AnimalStockCategory): void;
+    navigateToFarmManureTradingDetail(mode: FarmManureTradingMode, index: number, category?: FarmManureTradingCategory): void;
+    navigateToFarmManureTradingList(): void;
+    navigateToFodderDetail(mode: FodderMode, index: number, category?: FodderCategory): void;
+    navigateToFodderList(): void;
+    navigateToFieldSpreading(category?: FieldSpreadingCategory): void;
+    /** Deep-link to a specific row of a field spreading tab (e.g. from a validation error). */
+    navigateToFieldSpreadingDetail(category: FieldSpreadingCategory, index: number): void;
+    navigateToFieldCultivationDetail(tab: Exclude<FieldCultivationTab, 'general'>, index: number): void;
+    navigateToFieldCultivationList(tab?: FieldCultivationTab): void;
+    navigateToStorageDetail(type: StorageEntryType, index: number): void;
+    navigateToStorageList(tab?: StorageTab): void;
     /**
-     * Set active category/tab within animal stock detail (without changing page/entry).
+     * Set active category/tab for current page (without changing page/entry).
+     * Generic method supporting any page's categorization navigation.
+     * No-op when page and category are already the same values to prevent
+     * unnecessary signal emissions that re-trigger the tab index computed.
      */
-    setAnimalStockCategory(category: AnimalStockCategory): void;
+    setCategory(page: PageId, category: string): void;
     /**
      * Reset page-specific context when navigating away.
      * Prevents stale state (e.g., old selected index) from affecting new page.

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

@@ -0,0 +1,46 @@
+import { NaebiData } from '../data/naebi-data.service';
+import type { PlanningBalanceResponse } from './planning-balance.types';
+export type { PlanningBalanceResponse } from './planning-balance.types';
+/** Which backend to target for planning requests. */
+export type PlanningEndpoint = 'ebilanz' | 'blw';
+/**
+ * Sends NAEBI data to a planning endpoint and exposes the result as a
+ * signal-based resource. Call `runPlanning(data, endpoint)` to trigger a request.
+ *
+ * The ID counter ensures each call re-fetches even if the payload hasn't changed.
+ */
+export declare class PlanningBalanceService {
+    private readonly http;
+    private readonly metadataSvc;
+    private readonly _value;
+    private readonly _error;
+    private readonly _isLoading;
+    private readonly _selectedEndpoint;
+    private readonly _lastStartedRequestId;
+    private readonly _lastCompletedRequestId;
+    private readonly _lastSuccessfulRequestId;
+    private _nextId;
+    private activeRequestId;
+    private activeRequestSub;
+    readonly planningResource: {
+        value: import("@angular/core").Signal<PlanningBalanceResponse | undefined>;
+        error: import("@angular/core").Signal<unknown>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        hasValue: import("@angular/core").Signal<boolean>;
+        lastStartedRequestId: import("@angular/core").Signal<number>;
+        lastCompletedRequestId: import("@angular/core").Signal<number>;
+        lastSuccessfulRequestId: import("@angular/core").Signal<number>;
+    };
+    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, `nutrientCycle.generateReport` forced to true (the PDF report
+     * must always be requested on submission), 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/planning/planning-balance.types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * TypeScript interfaces for the planning-balance API response.
+ * These match the eBilanz / BLW response shape observed in the example data.
+ */
+/** A single nutrient quantity entry (kg or % unit). */
+export interface NutrientEntry {
+    molecularFormula: string;
+    quantity: number;
+    quantityCorrected?: number;
+    unit: string;
+    productFamilyType?: string;
+    typeOfManureRecyclingProduct?: string;
+    fertiliserProductCategory?: string;
+}
+export interface CalculationVersion {
+    version: string;
+    validFrom: string;
+    validTo: string;
+}
+export interface AreaAndYieldPerAgronomicCropCategory {
+    agronomicCropCategory: string;
+    areaSize: number;
+    effectiveYield: number;
+    isMainCrop: boolean;
+    isNutrientPoorFodder: boolean;
+    yieldPerSquareMeasure?: number;
+}
+export interface AreaPerCultivationType {
+    areaSize: number;
+    isMainCrop: boolean;
+}
+export interface AreaAndYieldPerCultivationCategory {
+    cultivationCategory: string;
+    areaAndYieldPerAgronomicCropCategory: AreaAndYieldPerAgronomicCropCategory[];
+    areaPerCultivationType: AreaPerCultivationType[];
+}
+export interface AreaPerSubCategory {
+    cultivationSubCategory: string;
+    areaSize: number;
+    isMainCrop: boolean;
+}
+export interface FieldCultivation {
+    areaAndYieldPerCultivationCategory: AreaAndYieldPerCultivationCategory[];
+    areaPerSubCategory: AreaPerSubCategory[];
+    fertilizableAreaSize: number;
+    slurrySpreadingAreaSize: number;
+    totalAgriculturalLandAreaSize: number;
+}
+export interface FodderQuantity {
+    quantity: number;
+    unit: string;
+    proportionNutrientPoorFodder?: number;
+}
+export interface FodderProduct {
+    typeOfFeedstuffProduct: string;
+    quantity: number;
+    unit: string;
+    isNutrientPoorFodder: boolean;
+}
+export interface ConsumptionAnimalStock {
+    animalCategoryPRIF: number;
+    averageQuantity: number;
+    order: string;
+    quantity: number;
+    unit: string;
+}
+export interface RequiredEffectiveYieldFromFodderCropland {
+    consumptionAnimalStock: ConsumptionAnimalStock[];
+    cropFromNonFodderCroplandPerProduct: FodderProduct[];
+    dispensePerProduct: FodderProduct[];
+    supplyPerProduct: FodderProduct[];
+    totalBalance: FodderQuantity;
+    totalConsumptionAnimalStock: FodderQuantity;
+    totalCropFromNonFodderCropland: FodderQuantity;
+    totalDispense: FodderQuantity;
+    totalSupply: FodderQuantity;
+}
+export interface FodderBalance {
+    requiredEffectiveYieldFromFodderCropland: RequiredEffectiveYieldFromFodderCropland;
+    totalBalance: FodderQuantity;
+    totalEffectiveYieldFromFodderCropland: FodderQuantity;
+    totalNutrientPoorFodder: FodderQuantity;
+}
+export interface EmissionAndAccumulationEntry {
+    animalCategoryPRIF: number;
+    order: string;
+    accumulation: NutrientEntry[];
+    emission: NutrientEntry[];
+    manureExcretion?: unknown[];
+}
+export interface AccumulationEntireExcretion {
+    animalCategoryPRIF: number;
+    order: string;
+    durationSumTotalCorrectedNutrientBalance: number;
+    accumulation: NutrientEntry[];
+}
+export interface TotalNutrientSet {
+    accumulation: NutrientEntry[];
+    emission?: NutrientEntry[];
+}
+export interface AnimalStock {
+    accumulationEntireExcretion: AccumulationEntireExcretion[];
+    emissionAndAccumulationPasture: EmissionAndAccumulationEntry[];
+    emissionAndAccumulationStall: EmissionAndAccumulationEntry[];
+    emissionAndAccumulationYard: EmissionAndAccumulationEntry[];
+    totalAccumulationEntireExcretion: TotalNutrientSet;
+    totalEmissionAndAccumulationAnimalStock: TotalNutrientSet;
+    totalEmissionAndAccumulationPasture: TotalNutrientSet;
+    totalEmissionAndAccumulationStall: TotalNutrientSet;
+    totalEmissionAndAccumulationYard: TotalNutrientSet;
+}
+export interface ManureTradingProduct {
+    typeOfManureRecyclingProduct: string;
+    quantity: number;
+    unit: string;
+    ingredient: NutrientEntry[];
+}
+export interface FarmManureTrading {
+    balancePerProduct: ManureTradingProduct[];
+    dispensePerProduct: ManureTradingProduct[];
+    supplyPerProduct: ManureTradingProduct[];
+    totalBalance: {
+        ingredient: NutrientEntry[];
+    };
+}
+export interface NutrientRequirementEntry {
+    agronomicCropCategory?: string;
+    cultivationCategory?: string;
+    isMainCrop?: boolean;
+    requirement: NutrientEntry[];
+}
+export interface FieldCultivationNutrients {
+    nutrientTransferUnfertilizedCultivation: NutrientEntry[];
+    requirementPerAgronomicCropCategory: NutrientRequirementEntry[];
+    requirementPerCultivationCategory: NutrientRequirementEntry[];
+    totalRequirement: NutrientEntry[];
+}
+export interface FieldSpreading {
+    emissionAndAccumulationFieldSpreading: TotalNutrientSet;
+    totalEmissionAndAccumulationFieldSpreading: TotalNutrientSet;
+}
+export interface StorageBalance {
+    emissionAndAccumulationManureStorage: TotalNutrientSet;
+    totalEmissionAndAccumulationManureStorage: TotalNutrientSet;
+}
+export interface NutrientBalance {
+    animalStock: AnimalStock;
+    farmManureTrading: FarmManureTrading;
+    fieldCultivation: FieldCultivationNutrients;
+    fieldSpreading: FieldSpreading;
+    storage: StorageBalance;
+    /** Final per-nutrient balance figures: kg lines + % lines interleaved. */
+    totalBalance: NutrientEntry[];
+    /** Farm-wide gas emissions (NH3, NO, N2O, N2). */
+    totalEmissionFarm: NutrientEntry[];
+    nutrientBalanceTMP?: unknown[];
+}
+export interface NutrientCycle {
+    creationDateTime: string;
+    facilitySpecificProducts: {
+        manureRecyclingProduct: unknown[];
+    };
+    fieldCultivation: FieldCultivation;
+    fodderBalance: FodderBalance;
+    nutrientBalance: NutrientBalance;
+    version: string;
+    /** Base64-encoded PDF report, if returned by the endpoint. */
+    report?: string;
+}
+export interface ValidationMessageDetail {
+    designation_deu: string;
+    designation_eng: string;
+    designation_fra: string;
+    designation_ita: string;
+}
+export interface ValidationMessage {
+    field: string;
+    type: string;
+    detail: ValidationMessageDetail;
+}
+/** Full response from the planning-balance endpoint. */
+export interface PlanningBalanceResponse {
+    calculationVersion: CalculationVersion;
+    nutrientCycle: NutrientCycle;
+    validationMessage: ValidationMessage[];
+}
+/** Merged kg + % row for the final balance table (Section D). */
+export interface BalanceRow {
+    molecularFormula: string;
+    quantity: number;
+    quantityCorrected: number;
+    quantityPct: number | null;
+    quantityCorrectedPct: number | null;
+    unit: 'kg';
+}
+/** Crop requirement row enriched with area and yield for display (Section C). */
+export interface CropRequirementRow {
+    cropCode: string;
+    cultivationCategory: string;
+    isMainCrop: boolean;
+    areaHa: number;
+    effectiveYield: number;
+    /** kg/ha yield per square measure field (m² basis), converted to dt/ha for display. */
+    yieldDtHa: number | null;
+    requirement: NutrientEntry[];
+}