@agridea/suibi-module 0.1.0-preview.00f7b5e

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

@@ -0,0 +1,38 @@
+import { AnimalCategorySelectRenderer } from '../renderers/controls/selects/animal-category/animal-category-select.renderer';
+import { CodeListSelectRenderer } from '../renderers/controls/selects/code-list/code-list-select.renderer';
+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';
+import { CustomArrayLayoutRenderer } from '../renderers/layout/array/array-layout.renderer';
+export declare const CUSTOM_JSONFORMS_RENDERERS: ({
+    tester: RankedTester;
+    renderer: typeof ConstraintLayoutRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof SelectedCategoryCategorizationRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof CardGroupRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof PlainGroupRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof LogicalGroupRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof ModuleToggleGroupRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof AnimalCategorySelectRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof CodeListSelectRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof CustomArrayLayoutRenderer;
+})[];

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

@@ -0,0 +1,24 @@
+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;
+    descriptor?: {
+        designation_ita?: string;
+        [k: string]: unknown;
+    };
+}
+export declare class AnimalCategorySelectRenderer extends BaseSelectControl<number> {
+    options: import("@angular/core").InputSignal<AnimalCategoryPrifEntry[]>;
+    private readonly masterData;
+    constructor(jsonFormsService: JsonFormsAngularService);
+    getEventValue: (event: any) => any;
+    optLabel(opt: AnimalCategoryPrifEntry): string;
+    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

@@ -0,0 +1,37 @@
+import { Signal } from '@angular/core';
+import { JsonFormsAngularService } from '@jsonforms/angular';
+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 autoDependsOnDataPath;
+    private scopePointerToDataPath;
+    private inferListKeyFromScope;
+    private readValueAtPath;
+    readonly filteredOptions: Signal<BaseCodeListEntry[]>;
+    constructor(jsonFormsService: JsonFormsAngularService);
+    getEventValue: (event: any) => any;
+    optionLabel(opt: BaseCodeListEntry): string;
+    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/array/array-layout.renderer.d.ts

@@ -0,0 +1,43 @@
+import { OnInit } from '@angular/core';
+import { JsonFormsAbstractControl, JsonFormsAngularService } from '@jsonforms/angular';
+import { ArrayLayoutProps, ArrayTranslations, JsonFormsState, OwnPropsOfRenderer, RankedTester, StatePropsOfArrayLayout, UISchemaElement, UISchemaTester } from '@jsonforms/core';
+/**
+ * CustomArrayLayoutRenderer
+ * Overrides the stock JSONForms `ArrayLayoutRenderer` (rank 4 → this is rank 5) to apply
+ * the project UX pattern: centered empty-state placeholder when the array has no entries,
+ * and the full-width dashed add-button always anchored below the list.
+ *
+ * The add button label is driven by `translations.addTooltip` resolved via the JSONForms
+ * i18n pipeline — configure per-array labels there.
+ */
+export declare class CustomArrayLayoutRenderer extends JsonFormsAbstractControl<StatePropsOfArrayLayout> implements OnInit {
+    noData: boolean;
+    /** Indices 0..n-1 used to render per-item cards and drive sort-button disabled state. */
+    indices: number[];
+    translations: ArrayTranslations;
+    showSortButtons: boolean;
+    addItem: (path: string, value: unknown) => () => void;
+    moveItemUp: (path: string, index: number) => () => void;
+    moveItemDown: (path: string, index: number) => () => void;
+    removeItems: (path: string, toDelete: number[]) => () => void;
+    uischemas: {
+        tester: UISchemaTester;
+        uischema: UISchemaElement;
+    }[];
+    constructor(jsonFormsService: JsonFormsAngularService);
+    get emptyText(): string;
+    get addLabel(): string;
+    mapToProps(state: JsonFormsState): StatePropsOfArrayLayout & {
+        translations: ArrayTranslations;
+    };
+    mapAdditionalProps(props: ArrayLayoutProps & {
+        translations: ArrayTranslations;
+    }): void;
+    remove(index: number): void;
+    add(): void;
+    up(index: number): void;
+    down(index: number): void;
+    ngOnInit(): void;
+    getProps(index: number): OwnPropsOfRenderer;
+}
+export declare const customArrayLayoutRendererTester: RankedTester;

package/dist/types/app/jsonforms/renderers/layout/categorization/selected-category-categorization.renderer.d.ts

@@ -0,0 +1,34 @@
+import { OnInit } from '@angular/core';
+import { JsonFormsBaseRenderer } from '@jsonforms/angular';
+import { Categorization, Category } from '@jsonforms/core';
+/**
+ * Custom categorization renderer with programmatic tab selection via NavigationService.
+ *
+ * Extends JSONForms default categorization by reading category keys from UI schema options
+ * and syncing with NavigationService.selectedCategory signal for deep-linking (e.g., validation errors).
+ *
+ * UI Schema: Add "options": { "categoryKey": "<key>" } to each Category element.
+ * Navigation: Call navigationSvc.setCategory(page, key) or navigate methods to select tabs programmatically.
+ * Bidirectional: User tab clicks update NavigationService state automatically.
+ */
+export declare class SelectedCategoryCategorizationRenderer extends JsonFormsBaseRenderer<Categorization> implements OnInit {
+    private readonly jsonFormsService;
+    private readonly navigationSvc;
+    hidden: boolean;
+    visibleCategories: (Category | Categorization)[];
+    categoryLabels: string[];
+    private readonly categoryKeyToIndex;
+    private readonly indexToCategoryKey;
+    private _prevCategorySignature;
+    readonly selectedTabIndex: import("@angular/core").Signal<number>;
+    ngOnInit(): void;
+    /**
+     * Build bidirectional category key ↔ tab index mapping from UI schema.
+     * Reads options.categoryKey from each visible Category element.
+     * Example: { base: 0, formOfDetention: 1, feeding: 2 }
+     * Skips signal writes when the tab structure hasn't changed (pure data changes
+     * fire $state on every keystroke; no need to mark selectedTabIndex stale each time).
+     */
+    private buildCategoryMappings;
+    onTabChange(newIndex: number): void;
+}

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

@@ -0,0 +1,31 @@
+import { JsonFormsBaseRenderer } from '@jsonforms/angular';
+import { Layout } from '@jsonforms/core';
+/**
+ * Layout renderer for a custom UI schema element:
+ * { type: 'Constraint', options: { constraint: { resolver, args } }, elements: [ ... ] }
+ *
+ * It conditionally instantiates its children based on a named constraint
+ * resolver (see constraint-resolvers.ts). No additional DOM wrapper is added;
+ * children participate directly in surrounding layout.
+ */
+export declare class ConstraintLayoutRenderer extends JsonFormsBaseRenderer<Layout> {
+    private readonly service;
+    private childrenHost?;
+    private subscription;
+    private _prevSig?;
+    private _elements;
+    private _schema;
+    private _path;
+    private _renderers;
+    private _cells;
+    private _constraintCfg;
+    private readonly masterData;
+    private readonly i18n;
+    private visible;
+    /** Test-only helper (not used in templates). */
+    isVisibleForTest(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private renderChildren;
+    private pickRenderer;
+}

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

@@ -0,0 +1,31 @@
+import { ChangeDetectorRef, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
+import { GroupLayout, JsonFormsCellRendererRegistryEntry, JsonFormsRendererRegistryEntry } from '@jsonforms/core';
+import { JsonFormsAngularService, JsonFormsBaseRenderer } from '@jsonforms/angular';
+export declare class BaseGroupRenderer extends JsonFormsBaseRenderer<GroupLayout> implements OnInit, OnDestroy {
+    protected readonly service: JsonFormsAngularService;
+    protected readonly cdr: ChangeDetectorRef;
+    protected _hidden: import("@angular/core").WritableSignal<boolean>;
+    protected _label: import("@angular/core").WritableSignal<string | undefined>;
+    protected _elements: import("@angular/core").WritableSignal<import("@jsonforms/core").UISchemaElement[]>;
+    protected _schema: import("@angular/core").WritableSignal<any>;
+    protected _path: import("@angular/core").WritableSignal<string>;
+    protected _renderers: import("@angular/core").WritableSignal<JsonFormsRendererRegistryEntry[]>;
+    protected _cells: import("@angular/core").WritableSignal<JsonFormsCellRendererRegistryEntry[] | undefined>;
+    protected _id: string;
+    hidden(): boolean;
+    label(): string | undefined;
+    labelId(): string | null;
+    elements(): import("@jsonforms/core").UISchemaElement[];
+    get currentPath(): string;
+    get currentSchema(): any;
+    registryRenderers(): JsonFormsRendererRegistryEntry[];
+    registryCells(): JsonFormsCellRendererRegistryEntry[] | undefined;
+    private subscription;
+    private _destroyed;
+    private _prevSig?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected resolveHost(): ViewContainerRef | undefined;
+    protected renderChildren(): void;
+    private pickRenderer;
+}

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

@@ -0,0 +1,6 @@
+import { ViewContainerRef } from '@angular/core';
+import { BaseGroupRenderer } from './base-group.renderer';
+export declare class CardGroupRenderer extends BaseGroupRenderer {
+    private childrenHost?;
+    protected resolveHost(): ViewContainerRef | undefined;
+}

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

@@ -0,0 +1,4 @@
+import { RankedTester } from '@jsonforms/core';
+export declare const cardGroupTester: RankedTester;
+export declare const plainGroupTester: RankedTester;
+export declare const logicalGroupTester: RankedTester;

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

@@ -0,0 +1,6 @@
+import { ViewContainerRef } from '@angular/core';
+import { BaseGroupRenderer } from './base-group.renderer';
+export declare class LogicalGroupRenderer extends BaseGroupRenderer {
+    private childrenHost?;
+    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/renderers/layout/group/plain-group.renderer.d.ts

@@ -0,0 +1,6 @@
+import { ViewContainerRef } from '@angular/core';
+import { BaseGroupRenderer } from './base-group.renderer';
+export declare class PlainGroupRenderer extends BaseGroupRenderer {
+    private childrenHost?;
+    protected resolveHost(): ViewContainerRef | undefined;
+}

package/dist/types/app/jsonforms/shared/base-control/base-select-control.d.ts

@@ -0,0 +1,16 @@
+import { JsonFormsAngularService, JsonFormsControl } from '@jsonforms/angular';
+/**
+ * Lightweight abstraction for select-like JsonForms controls.
+ * Provides a uniform selection change handler and validation trigger.
+ * Concrete subclasses supply template + option source + label logic.
+ *
+ * Also injects custom validation errors from FieldErrorService into the FormControl
+ * so Angular Material mat-error displays them automatically.
+ */
+export declare abstract class BaseSelectControl<TValue = number> extends JsonFormsControl {
+    constructor(jsonFormsService: JsonFormsAngularService);
+    /** Override if event value extraction differs */
+    getEventValue: (event: any) => any;
+    /** Invoke when the user picks a new value. */
+    protected commitValue(value: TValue): void;
+}

package/dist/types/app/jsonforms/shared/option-sources/code-lists.d.ts

@@ -0,0 +1,11 @@
+export interface BaseCodeListEntry {
+    id: number | string;
+    [k: string]: unknown;
+    descriptor?: Record<string, unknown>;
+}
+export declare const CODE_LISTS: Record<string, BaseCodeListEntry[]>;
+export declare const PATH_TO_LIST_KEY: Array<{
+    regex: RegExp;
+    key: keyof typeof CODE_LISTS;
+}>;
+export declare function resolveCodeListKey(tail: string): string | null;

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/jsonforms/shared/validation/field-error.service.d.ts

@@ -0,0 +1,18 @@
+import { ErrorObject } from 'ajv';
+/**
+ * Service to share validation errors from JSONForms across custom renderers.
+ * Allows renderers to display field-specific errors from custom AJV keywords.
+ */
+export declare class FieldErrorService {
+    private readonly errors;
+    /** Update the global error list from JSONForms validation */
+    setErrors(errors: ErrorObject[] | null): void;
+    /** Get error message for a specific field path */
+    getErrorForPath(scopeOrInstancePath: string): string | null;
+    /** Get all errors for a specific field path */
+    getErrorsForPath(scopeOrInstancePath: string): ErrorObject[];
+    /** Clear all errors */
+    clearErrors(): void;
+    private normalizeScope;
+    private normalizeInstancePath;
+}

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/animal-stock-list.component.d.ts

@@ -0,0 +1,18 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { AnimalStockRow } from '../animal-stock.types';
+export declare class AnimalStockListComponent {
+    private readonly masterData;
+    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;
+    }>;
+    displayedColumns: string[];
+    onDelete(index: number, event: Event): void;
+    drop(event: CdkDragDrop<AnimalStockRow[]>): void;
+    resolveAnimalCategory(id: unknown): string;
+    resolveUtilisation(id: unknown): string;
+}

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

@@ -0,0 +1,24 @@
+import { AnimalStockRow } from '../animal-stock.types';
+import { LifetimePerformance } from '../../lifetime-performance/lifetime-performance.types';
+export declare class AnimalStockMasterDetailComponent {
+    private readonly dataSvc;
+    private readonly navigationSvc;
+    constructor();
+    readonly rows: import("@angular/core").Signal<AnimalStockRow[]>;
+    readonly lifetimePerformance: import("@angular/core").Signal<LifetimePerformance | null>;
+    readonly selectedIndex: import("@angular/core").WritableSignal<number | null>;
+    readonly detailData: import("@angular/core").Signal<any>;
+    openDetail(index: number): void;
+    closeDetail(): void;
+    onRowClick(_row: AnimalStockRow, index: number): void;
+    addRow(): void;
+    deleteRow(index: number): void;
+    reorderRow(event: {
+        previousIndex: number;
+        currentIndex: number;
+    }): void;
+    onDetailChange(newData: any): void;
+    onLifetimePerformanceChange(payload: LifetimePerformance): void;
+    private patchRows;
+    private patchLifetimePerformance;
+}

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

@@ -0,0 +1,69 @@
+export interface FeedingRoutineItem {
+    typeOfFeedstuffProduct?: string;
+    transactionUnit?: string;
+    quantity?: number;
+}
+export interface SeasonalFeeding {
+    feedingRoutine?: FeedingRoutineItem[];
+    dailyConcentratedFeedstuff?: {
+        quantity?: number;
+    };
+}
+export interface Feeding {
+    fodderConsumption?: number;
+    concentratedFeedstuffConsumption?: number;
+    winterFeeding?: SeasonalFeeding;
+    summerFeeding?: SeasonalFeeding;
+}
+export interface Stall {
+    stableSystem?: number;
+    stableCapacity?: number;
+    stableVentilationType?: number | null;
+    stableAirPurification?: number | null;
+    hasStableDeepLitter?: boolean;
+    hasStableManureBeltDrying?: boolean;
+    stableManureRemovalFrequency?: number | null;
+    stableWaterSupply?: number | null;
+    hasStableManureAndSlurryProduction?: boolean;
+    hasStableFeedingStationElevated?: boolean;
+    hasStableFloorSlopedUrineDrainage?: boolean;
+    hasYard?: boolean;
+    yardFeeding?: number | null;
+    yardFloorType?: number | null;
+    yardDays?: number;
+    yardHoursPerDay?: number;
+}
+export interface Pasture {
+    days?: number;
+    hoursPerDay?: number;
+}
+export interface FormOfDetention {
+    hasGrazing?: boolean;
+    pasture?: Pasture;
+    stall?: Stall;
+}
+export interface LivestockReport {
+    durationSumTotalNutrientBalance?: number;
+}
+export interface SelfReportedLivestock {
+    averageQuantity?: number;
+}
+export interface LinearCorrection {
+    duration?: number;
+}
+export interface AnimalStockRow {
+    order?: number | string;
+    animalCategoryPRIF?: number;
+    livestockReportViaAnimalTracingOriginal?: LivestockReport;
+    livestockReportedViaAnimalTracingFinal?: LivestockReport;
+    selfReportedLivestock?: SelfReportedLivestock;
+    durationCorrectionQuantity?: number;
+    durationCorrectionDays?: number;
+    hasImpexDerivedExcretion?: boolean;
+    hasLinearCorrectionDerivedExcretion?: boolean;
+    linearCorrection?: LinearCorrection;
+    utilisation?: number;
+    formOfDetention?: FormOfDetention;
+    feeding?: Feeding;
+    [key: string]: unknown;
+}

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

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