@agridea/suibi-module 0.1.0-preview.09bcbd4

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

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

@@ -0,0 +1,10 @@
+import type { BalanceRow, NutrientEntry } from './planning-balance.types';
+/**
+ * Merges the interleaved kg / % rows from `totalBalance` into one `BalanceRow`
+ * per nutrient formula, preserving the canonical KEY_NUTRIENTS display order.
+ *
+ * The planning-balance API returns two `NutrientEntry` objects per formula
+ * (one with `unit === 'kg'`, one with `unit === '%'`). This function coalesces
+ * them so callers work with a single, normalised row.
+ */
+export declare function mergeBalanceRows(totalBalance: NutrientEntry[]): BalanceRow[];

package/dist/types/app/core/schemas/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Schema utilities for managing UI-only helper fields in JSONForms components.
+ *
+ * This module provides centralized schema merging and helper field filtering to maintain
+ * clean separation between domain schemas (nutrient balance calculation model) and
+ * UI-only helper fields that drive conditional rendering logic.
+ *
+ * @example
+ * ```typescript
+ * import { mergeSchemas, getUiHelperFields, stripUiHelpers } from '@core/schemas';
+ * import globalUiExtensions from '@core/schemas/ui-schema-extensions.json';
+ *
+ * const helpers = getUiHelperFields(globalUiExtensions);
+ * const merged = mergeSchemas(domainSchema, globalUiExtensions);
+ * const clean = stripUiHelpers(formData, helpers);
+ * ```
+ */
+export { mergeSchemas, getUiHelperFields, stripUiHelpers } from './schema-merge.util';

package/dist/types/app/core/schemas/schema-localization.util.d.ts

@@ -0,0 +1,18 @@
+import { UISchemaElement } from '@jsonforms/core';
+/**
+ * Deeply clones a UI schema and translates its labels.
+ *
+ * This utility is essential for JSONForms integration in a multi-language environment.
+ * Since UI schemas are typically static JSON objects, we must clone them before
+ * modifying their labels to avoid mutating the shared source or leaking translations
+ * across language switches.
+ *
+ * It traverses:
+ * - Nested `elements` arrays (standard layouts)
+ * - `options.detail` objects (often used in array controls)
+ *
+ * @param ui The original UI schema to localize
+ * @param translate A function that takes a translation key and returns the translated string
+ * @returns A new UI schema object with translated labels
+ */
+export declare function cloneAndLocalize(ui: any, translate: (key: string) => string): UISchemaElement;

package/dist/types/app/core/schemas/schema-merge.util.d.ts

@@ -0,0 +1,26 @@
+import { JsonSchema } from '@jsonforms/core';
+/**
+ * Merges a base domain schema with UI-only extension properties at runtime.
+ * Extensions are deep-cloned into the base schema to avoid mutation.
+ *
+ * @param base - Domain schema (e.g., nutrient balance data model)
+ * @param extensions - UI helper schema with `x-ui-helper: true` fields
+ * @returns Merged schema suitable for JSONForms consumption
+ */
+export declare function mergeSchemas(base: JsonSchema, extensions: JsonSchema): JsonSchema;
+/**
+ * Extracts field names marked as UI helpers from a schema.
+ * Scans properties for `"x-ui-helper": true` metadata.
+ *
+ * @param schema - Schema to scan (typically UI extensions schema)
+ * @returns Set of field names that should be filtered from persisted data
+ */
+export declare function getUiHelperFields(schema: JsonSchema): Set<string>;
+/**
+ * Removes all UI helper fields from a data object.
+ * Mutates the input object (use with caution; prefer spreading first).
+ *
+ * @param data - Data object to clean (typically form state)
+ * @param helperFields - Set of field names to remove
+ */
+export declare function stripUiHelpers<T extends Record<string, any>>(data: T, helperFields: Set<string>): Omit<T, string>;

package/dist/types/app/core/schemas/ui-helper-registry.d.ts

@@ -0,0 +1,16 @@
+export interface UiHelperDefinitions {
+    durationSourceType?: 'tvd-original' | 'tvd-final' | 'self-reported';
+    quantity_correction?: boolean;
+}
+export interface UiHelperConfig<K extends keyof UiHelperDefinitions = keyof UiHelperDefinitions> {
+    key: K;
+    default: () => UiHelperDefinitions[K] | undefined;
+    derive?: (domain: any) => UiHelperDefinitions[K] | undefined;
+    readonly?: boolean;
+}
+export declare function getHelperKeys(): (keyof UiHelperDefinitions)[];
+export declare function deriveHelpers(domain: any): Partial<UiHelperDefinitions>;
+export declare function augmentData<T extends object>(domain: T): T & UiHelperDefinitions;
+export declare function stripHelpers<T extends object>(data: T): T;
+export declare function prepareJsonFormsData<T extends object>(domain: T | null | undefined): (T & UiHelperDefinitions) | null;
+export declare function sanitizeJsonFormsData<T extends object>(formData: T): T;

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

@@ -0,0 +1,12 @@
+export declare class TelemetryService {
+    private appInsights;
+    private isEnabled;
+    constructor();
+    private init;
+    setTelemetryEnabled(enabled: boolean): void;
+    trackPageView(name?: string, uri?: string): void;
+    trackEvent(name: string, properties?: {
+        [key: string]: any;
+    }): void;
+    trackException(exception: Error): void;
+}

package/dist/types/app/core/utils/object.util.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Recursively compares two values for deep equality.
+ *
+ * Useful for checking if complex objects or arrays have changed content,
+ * often used in change detection strategies or form dirty checking.
+ *
+ * @param a The first value to compare
+ * @param b The second value to compare
+ * @returns True if the values are deeply equal, false otherwise
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Creates a deep copy of a value.
+ *
+ * Essential for immutable state updates where you need to modify a nested property
+ * without mutating the original object.
+ *
+ * Uses `structuredClone` if available, falling back to JSON serialization.
+ * Note: The JSON fallback has limitations (e.g. loses Date objects, functions, undefined).
+ *
+ * @param value The value to clone
+ * @returns A deep copy of the value
+ */
+export declare function deepClone<T>(value: T): T;

package/dist/types/app/core/validation/ajv-custom.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom AJV instance with capability-based validation keywords.
+ * Focus: keep declarative business rules in JSON Schema while deriving dynamic
+ * constraints from static master data (no runtime HTTP calls).
+ */
+import Ajv from 'ajv';
+/**
+ * Creates a custom AJV instance with domain-specific validation keywords.
+ *
+ * Custom keywords:
+ * - `permittedStableSystem`: Validates stable system against animal category constraints
+ *
+ * @param options - Additional AJV options to merge with defaults
+ */
+export declare function createSuibiAjv(options?: Record<string, any>): Ajv;

package/dist/types/app/core/validation/capabilities.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dynamic capability derivation from master data.
+ * Computes permitted stable systems, utilisations, etc. based on animal categories.
+ *
+ * All master data is embedded statically at compile time - no runtime HTTP calls.
+ */
+/**
+ * Derives permitted stable systems (stableSystem enum strings) for a given animal category.
+ *
+ * @param animalCategoryPRIF - The PRIF animal category ID
+ * @returns Array of permitted stableSystem enum strings (e.g. 'HUS_TETHER')
+ */
+export declare function derivePermittedStableSystems(animalCategoryPRIF: number | null | undefined): string[];
+/**
+ * Pre-computed map for performance (memoized at module load).
+ * Maps animalCategoryPRIF -> array of permitted stableSystem enum strings.
+ */
+export declare const PERMITTED_STABLE_SYSTEMS: Record<number, string[]>;

package/dist/types/app/core/validation/error-formatter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Error message formatter for JSON Schema validation.
+ * Maps AJV error objects to i18n keys with parameters.
+ *
+ * Since validation is handled by AJV/JSON Schema, we don't need a custom engine.
+ * We just need to format error messages for better UX.
+ */
+/**
+ * Format an AJV error object for display, mapping to i18n keys where applicable.
+ *
+ * @param error AJV error object
+ * @param translateFn Translation function (key, defaultMessage) => string
+ * @returns Formatted error message
+ */
+export declare function formatValidationError(error: any, translateFn: (key: string, defaultMessage?: string) => string): string;
+/**
+ * Format multiple AJV errors for display.
+ */
+export declare function formatValidationErrors(errors: any[], translateFn: (key: string, defaultMessage?: string) => string): string[];

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

@@ -0,0 +1,59 @@
+import { ErrorObject } from 'ajv';
+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;
+    /** Navigation target: page */
+    targetPage?: PageId;
+    /** Navigation target: animal stock array index */
+    targetAnimalStockIndex?: number;
+    /** Navigation target: detail category (tab) */
+    targetCategory?: AnimalStockCategory;
+    /** Navigation target: static section (e.g., lifetime performance panel) */
+    targetSection?: 'lifetimePerformance';
+    /** Navigation target: farm manure trading tab */
+    targetFarmManureTradingMode?: FarmManureTradingMode;
+    /** Navigation target: farm manure trading entry index */
+    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;
+    /** 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
+ * Validates the entire NaebiData structure using the root JSON Schema + AJV.
+ * Consolidates errors and enriches them with navigation metadata for deep-linking.
+ *
+ * Usage: Inject in App or top-level components; errors() signal exposes enriched errors.
+ */
+export declare class GlobalValidationService {
+    private readonly dataSvc;
+    private readonly ajv;
+    private readonly validateFn;
+    readonly errors: import("@angular/core").Signal<EnrichedValidationError[]>;
+    private consolidateErrors;
+    private enrichErrors;
+    private inferCategory;
+    private inferFarmTradingCategory;
+    private inferFieldSpreadingCategory;
+    private inferFodderCategory;
+    private inferStorageTab;
+    private inferFieldLabel;
+}

package/dist/types/app/core/validation/validation-errors-panel.d.ts

@@ -0,0 +1,36 @@
+import { ErrorObject } from 'ajv';
+/**
+ * ValidationErrorsPanelComponent
+ * Reusable expansion panel summarizing & listing AJV validation issues.
+ * - Collapsed summary shows count + error icon.
+ * - Expands to list formatted, translated messages (stable ordering).
+ * - Hides entirely when there are no errors.
+ * - Emits `errorSelected` when user clicks an error (for navigation).
+ * Inputs:
+ *   errors: ErrorObject[] (raw / consolidated) – consumer decides consolidation strategy.
+ *   clickable: boolean – when true, list items are interactive and emit selection events.
+ * Outputs:
+ *   errorSelected: ErrorObject – emitted when user clicks an error item.
+ */
+export declare class ValidationErrorsPanelComponent {
+    /** Raw (or already consolidated) AJV errors */
+    errors: import("@angular/core").InputSignal<ErrorObject<string, Record<string, any>, unknown>[] | null | undefined>;
+    /** When true, list items are clickable and emit errorSelected */
+    clickable: import("@angular/core").InputSignal<boolean>;
+    /** Emitted when user clicks an error (only if clickable is true) */
+    errorSelected: import("@angular/core").OutputEmitterRef<ErrorObject<string, Record<string, any>, unknown>>;
+    private readonly i18n;
+    expanded: import("@angular/core").WritableSignal<boolean>;
+    hasErrors: import("@angular/core").Signal<boolean>;
+    /** Stable sort: by instancePath then keyword for predictability */
+    private sortedErrors;
+    formattedItems: import("@angular/core").Signal<{
+        message: string;
+        field: string;
+        error: ErrorObject<string, Record<string, any>, unknown>;
+    }[]>;
+    issueCountLabel: import("@angular/core").Signal<string>;
+    panelAriaLabel: import("@angular/core").Signal<string>;
+    collapse(): void;
+    onErrorClick(error: ErrorObject): void;
+}

package/dist/types/app/header-bar.d.ts

@@ -0,0 +1,14 @@
+import { Locale } from './core/i18n/i18n.service';
+import { PageId } from './core/navigation/navigation.service';
+/**
+ * HeaderBarComponent
+ * Footer actions for quick access to data preview and the current save state.
+ */
+export declare class HeaderBarComponent {
+    locale: import("@angular/core").InputSignal<Locale>;
+    currentPage: import("@angular/core").InputSignal<PageId>;
+    isDirty: import("@angular/core").InputSignal<boolean>;
+    onNavigate: import("@angular/core").InputSignal<(page: PageId) => void>;
+    onLocaleChange: import("@angular/core").InputSignal<(locale: Locale) => void>;
+    navigate(page: PageId): void;
+}

package/dist/types/app/jsonforms/constraints/constraint-resolvers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Constraint resolver registry enabling UI schema elements to declare dynamic
+ * visibility rules referencing domain-specific predicates. A resolver is a
+ * pure function returning a boolean. It receives a contextual accessor for
+ * current form data (root object) plus master-data + locale.
+ *
+ * UI schema structured example:
+ * {
+ *   "type": "Constraint",
+ *   "options": {
+ *     "constraint": {
+ *       "resolver": "animalCategory_isPermittedForConcentratedFeedstuffSummering",
+ *       "args": ["#/animalCategoryPRIF"],
+ *       "fallbackVisible": false
+ *     }
+ *   },
+ *   "elements": [ { "type": "Group", ... } ]
+ * }
+ */
+import { MasterDataService } from '../../core/master-data/master-data.service';
+import { I18nService } from '../../core/i18n/i18n.service';
+export interface ConstraintCall {
+    resolver: string;
+    args?: unknown[];
+    fallbackVisible?: boolean;
+}
+export type ConstraintConfig = ConstraintCall;
+export interface ConstraintContext {
+    /** Root data object from JSONForms state */
+    data: unknown;
+    /** Dereference a JSON Pointer (starts with '#/'); returns undefined if invalid */
+    get<T = unknown>(pointer: string): T | undefined;
+    /** Master-data service */
+    masterData: MasterDataService;
+    /** Current locale (from I18nService) */
+    locale: string;
+}
+export type ConstraintResolver = (ctx: ConstraintContext, ...args: any[]) => boolean;
+export declare function registerConstraint(name: string, fn: ConstraintResolver): void;
+/**
+ * Evaluate a constraint configuration.
+ * @param cfg constraint object (or undefined => visible)
+ * @param data current form data root
+ * @param services injected service wrappers
+ * @param ctxOverrides optional context override (testing/extensibility)
+ */
+export declare function evaluateConstraint(cfg: ConstraintConfig | undefined, data: unknown, services: {
+    masterData: MasterDataService;
+    i18n: I18nService;
+}, ctxOverrides?: Partial<ConstraintContext>): boolean;

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

@@ -0,0 +1,63 @@
+/**
+ * Code list filtering engine & resolver registry.
+ *
+ * Purpose: Allow UI schema controls rendering code list selects to declaratively
+ * filter the available options based on current form data (JSONForms), master data,
+ * locale, and arbitrary domain predicates – without baking domain logic into the
+ * generic select renderer.
+ *
+ * UI schema extension example (implicit generic filter using entryField/valueFrom):
+ * {
+ *   "type": "Control",
+ *   "scope": "#/properties/formOfDetention/properties/stall/properties/stableManureRemovalFrequency",
+ *   "options": {
+ *     "codeList": { "filter": { "entryField": "permittedForStableSystem", "valueFrom": "#/formOfDetention/stall/stableSystem", "fallback": "all" } }
+ *   }
+ * }
+ *
+ * Named resolver example:
+ *   "filter": { "resolver": "stableManureRemoval_permittedForSystem", "args": ["#/formOfDetention/stall/stableSystem"], "fallback": "all" }
+ */
+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;
+    i18n: I18nService;
+}
+export type CodeListFilterResolver = (ctx: FilterContext, entry: BaseCodeListEntry, ...args: any[]) => boolean;
+export interface LeafFilterCall {
+    resolver?: string;
+    args?: unknown[];
+    entryField?: string;
+    valueFrom?: string;
+    fallback?: 'all' | 'none';
+}
+export type FilterConfig = LeafFilterCall | {
+    all: FilterConfig[];
+    fallback?: 'all' | 'none';
+} | {
+    any: FilterConfig[];
+    fallback?: 'all' | 'none';
+} | {
+    not: FilterConfig;
+    fallback?: 'all' | 'none';
+} | {
+    true: boolean;
+    fallback?: 'all' | 'none';
+};
+export declare function registerCodeListFilter(name: string, fn: CodeListFilterResolver): void;
+/**
+ * Public entry to filter a list. Returns the provided list unchanged if cfg is falsy or
+ * if top-level fallback === 'all' and an unrecoverable error occurs.
+ */
+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

@@ -0,0 +1,34 @@
+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 { 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 AnimalCategorySelectRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof CodeListSelectRenderer;
+} | {
+    tester: RankedTester;
+    renderer: typeof CustomArrayLayoutRenderer;
+})[];