@meshmakers/octo-ui 3.4.310 → 3.4.330

package/types/meshmakers-octo-ui.d.ts

@@ -5,6 +5,7 @@ import { SVGIcon } from '@progress/kendo-svg-icons';
 import { AttributeItem, AttributeValueTypeDto as AttributeValueTypeDto$1, CkTypeSelectorItem as CkTypeSelectorItem$1, RtEntityDto, FieldFilterDto, SearchFilterDto, SortDto, CkModelDto, CkTypeDto, GraphDirectionDto, RtAssociationDto, FieldFilterOperatorsDto, GetCkTypesDtoGQL, RuntimeEntityItem, RuntimeEntitySelectDataSource, RuntimeEntityDialogDataSource } from '@meshmakers/octo-services';
 import { GridDataResult, CellClickEvent, RowArgs, PageChangeEvent, SelectionEvent } from '@progress/kendo-angular-grid';
 import { TreeItemDataTyped, TreeItemData, CommandItemExecuteEventArgs, CommandItem } from '@meshmakers/shared-services';
+import * as _meshmakers_octo_ui from '@meshmakers/octo-ui';
 import { ControlValueAccessor, Validator, FormControl, AbstractControl, ValidationErrors } from '@angular/forms';
 import { AutoCompleteComponent, PopupSettings } from '@progress/kendo-angular-dropdowns';
 import { DataSourceTyped, ListViewComponent, HierarchyDataSourceBase, ListViewMessages, FetchDataOptions, FetchResultTyped, BaseTreeDetailComponent, NodeDroppedEvent, TreeComponent } from '@meshmakers/shared-ui';
@@ -12,6 +13,17 @@ import { State } from '@progress/kendo-data-query/dist/npm/state';
 import { Observable } from 'rxjs';
 import { Routes } from '@angular/router';
 
+/**
+ * Helpers for the entity-selector suffix on navigation column paths (AB#4323):
+ * `nav.type[rtId=...]->attr`, `nav.type[wellKnownName=...]->attr` or
+ * `nav.type[attributeName=value]->attr`.
+ *
+ * The selector pins the exact target entity of a value navigation across an
+ * N-multiplicity association. It always attaches to the FIRST navigation type
+ * segment (the hop that crosses the association).
+ */
+type EntitySelectorKind = 'rtId' | 'wellKnownName' | 'attribute';
+
 interface AttributeSelectorDialogData {
     rtCkTypeId: string;
     selectedAttributes?: string[];
@@ -23,6 +35,8 @@ interface AttributeSelectorDialogData {
     additionalAttributes?: AttributeItem[];
     /** When true, hides the navigation properties checkbox and max depth controls */
     hideNavigationControls?: boolean;
+    /** When true, value columns across inbound / N-multiplicity associations are offered (first-match semantics, AB#4323) */
+    includeManyNavigations?: boolean;
     /** When set, restricts the available attributes to only these attribute paths (filtered client-side after fetching) */
     attributePaths?: string[];
 }
@@ -44,6 +58,7 @@ declare class AttributeSelectorDialogComponent implements OnInit {
     protected readonly searchIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly arrowUpIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly arrowDownIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly pencilIcon: _progress_kendo_svg_icons.SVGIcon;
     private _data;
     get data(): AttributeSelectorDialogData;
     set data(value: AttributeSelectorDialogData);
@@ -56,7 +71,17 @@ declare class AttributeSelectorDialogComponent implements OnInit {
     selectedValueTypeFilter: AttributeValueTypeDto$1 | null;
     includeNavigationProperties: boolean;
     maxDepth: number | null;
+    includeManyNavigations: boolean;
     hideNavigationControls: boolean;
+    selectorEditorTarget: AttributeItem | null;
+    selectorEditorBasePath: string;
+    selectorKind: EntitySelectorKind;
+    selectorAttributeName: string;
+    selectorValue: string;
+    readonly selectorKindOptions: {
+        text: string;
+        value: EntitySelectorKind;
+    }[];
     private attributePathsSet;
     availableAttributes: AttributeItem[];
     selectedAttributes: AttributeItem[];
@@ -75,6 +100,14 @@ declare class AttributeSelectorDialogComponent implements OnInit {
     onSearchChange(value: string): void;
     onValueTypeFilterChange(_value: AttributeValueTypeDto$1 | null): void;
     onNavigationPropertiesChange(): void;
+    onIncludeManyNavigationsChange(): void;
+    hasNavigation(path: string): boolean;
+    openSelectorEditor(item: AttributeItem): void;
+    canApplySelector(): boolean;
+    applySelectorToTarget(): void;
+    removeSelectorFromTarget(): void;
+    closeSelectorEditor(): void;
+    private rewriteSelectedPath;
     onMaxDepthChange(value: number | null): void;
     addSelected(): void;
     removeSelected(): void;
@@ -450,9 +483,19 @@ interface AttributeItemLike {
     value?: unknown;
 }
 /**
- * Extracts the list of available data point names from an entity's attribute
- * list. Always includes {@link DEFAULT_DATA_POINT} first; named state entries
- * follow in alphabetical order.
+ * One data point of a source entity: its name plus — when the record or the
+ * entity carries one — its last known value. `currentValue` is `undefined`
+ * when unknown (never `null`-normalised, so a real null value stays visible).
+ */
+interface DataPointInfo {
+    name: string;
+    currentValue?: unknown;
+}
+/**
+ * Extracts the available data points (name + last known value) from an
+ * entity's attribute list. Always includes {@link DEFAULT_DATA_POINT} first
+ * (carrying the entity's own `CurrentValue` attribute when present); named
+ * state entries follow in alphabetical order.
  *
  * Tolerates the three record shapes the platform produces for a RecordArray:
  *
@@ -460,8 +503,13 @@ interface AttributeItemLike {
  * 2. Pipeline / MongoDB: each record is `{ attributes: { Name: "…", ExternalId: "…" } }`.
  * 3. Flat: each record is `{ Name: "…", ExternalId: "…" }` (older dumps / sample data).
  *
- * Returns `[DEFAULT_DATA_POINT]` for null/undefined input, attributes without a
- * States/DataPoints entry, or malformed RecordArrays.
+ * Returns `[{ name: DEFAULT_DATA_POINT }]` for null/undefined input, attributes
+ * without a States/DataPoints entry, or malformed RecordArrays.
+ */
+declare function extractDataPoints(attributes: readonly (AttributeItemLike | null | undefined)[] | null | undefined): DataPointInfo[];
+/**
+ * Extracts the list of available data point names from an entity's attribute
+ * list — the name-only view of {@link extractDataPoints}.
  */
 declare function extractDataPointNames(attributes: readonly (AttributeItemLike | null | undefined)[] | null | undefined): string[];
 
@@ -502,8 +550,17 @@ declare class DataPointPickerComponent {
     /** Emits whenever the user enters a custom filter — useful for callers that
      *  want to refine a backing catalogue independently of the value selection. */
     readonly filterChange: _angular_core.OutputEmitterRef<string>;
-    protected readonly options: _angular_core.WritableSignal<string[]>;
+    /** Loaded data points incl. their last known values. */
+    private readonly dataPointInfos;
+    protected readonly options: _angular_core.Signal<string[]>;
     protected readonly loading: _angular_core.WritableSignal<boolean>;
+    /**
+     * Last known value of the currently selected data point, or undefined when
+     * the selection is a custom/unknown name or the source carries no value.
+     * Public so hosts (e.g. the mapping-edit dialog's expression preview) can
+     * read it off a template reference.
+     */
+    readonly currentValue: _angular_core.Signal<unknown>;
     /**
      * Current filter text entered into the combobox. Drives the case-insensitive
      * *contains* match below. Kendo's combobox by default does not filter the
@@ -539,7 +596,15 @@ declare class DataPointResolverService {
             items?: readonly (AttributeItemLike | null | undefined)[] | null;
         } | null;
     } | null | undefined): string[];
+    /** Like {@link extractFromEntity}, but keeps each data point's last known value. */
+    extractInfosFromEntity(entity: {
+        attributes?: {
+            items?: readonly (AttributeItemLike | null | undefined)[] | null;
+        } | null;
+    } | null | undefined): DataPointInfo[];
     load(rtId: string, ckTypeId: string): Promise<string[]>;
+    /** Like {@link load}, but keeps each data point's last known value. */
+    loadInfos(rtId: string, ckTypeId: string): Promise<DataPointInfo[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataPointResolverService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<DataPointResolverService>;
 }
@@ -770,6 +835,12 @@ interface AssociationGroupNode {
     roleId: string;
     targetCkTypeId: string;
     direction: GraphDirectionDto;
+    /**
+     * rtId of the GRANDparent entity (the tree parent of the entity this group
+     * belongs to). Its targets exclude this entity so the node the user came from
+     * does not reappear inside the group (direct-parent back-edge suppression).
+     */
+    excludeRtId?: string;
 }
 declare class RuntimeBrowserDataSource extends OctoGraphQlHierarchyDataSource<BrowserItem$3> {
     private readonly getTreesDtoGQL;
@@ -792,12 +863,6 @@ declare class RuntimeBrowserDataSource extends OctoGraphQlHierarchyDataSource<Br
      * `fetchChildren()` to apply the root-level whitelist for `Type` perspectives.
      */
     private activePerspective;
-    /**
-     * rtIds of the current perspective's root nodes. The primary/secondary role
-     * whitelist is applied ONLY to the direct children of these roots — deeper
-     * nodes keep full auto-discovery (whitelist-at-root-only).
-     */
-    private readonly perspectiveRootRtIds;
     /**
      * Selects the active perspective by key. The host is responsible for reloading
      * the tree afterwards (e.g. `treeDetail.refreshTree()`), which re-runs
@@ -813,15 +878,25 @@ declare class RuntimeBrowserDataSource extends OctoGraphQlHierarchyDataSource<Br
      * entry, so the host can hide the switcher.
      */
     getPerspectives(): Promise<PerspectiveDefinition[]>;
+    /**
+     * The graph direction the active perspective navigates its root roles in
+     * (AB#4263). Defaults to Inbound (the containment side, as for auto-discovery);
+     * `primaryDirection: Outbound` is required when the association is authored on
+     * the root entity (e.g. DistributionSystem --SystemMembers--> members). Applied
+     * to the whole root whitelist (primary + secondary) for simplicity.
+     */
+    private perspectiveNavDirection;
     /**
      * The role-id whitelist of the active perspective (primary + secondary), or
      * null when the perspective is not a `Type` perspective or declares no roles.
      */
     private activePerspectiveWhitelist;
     /**
-     * The set of role ids the given entity's direct children are restricted to,
-     * or null for full auto-discovery. Non-null only when the entity is a root of
-     * the active `Type` perspective (whitelist-at-root-only).
+     * The set of role ids the given tree item's direct children are restricted to,
+     * or null for full auto-discovery. Non-null only when the item is a TOP-LEVEL
+     * root of the active `Type` perspective (whitelist-at-root-only) — identified
+     * by its id prefix, so a root entity recurring deeper in the tree is NOT
+     * re-treated as a root (which would cycle).
      */
     private rootWhitelistFor;
     /**
@@ -840,17 +915,40 @@ declare class RuntimeBrowserDataSource extends OctoGraphQlHierarchyDataSource<Br
      * created fresh per browser/picker mount.
      */
     private readonly inboundRolesCache;
+    /**
+     * Same as inboundRolesCache but for OUTBOUND roles (AB#4263). A `Type`
+     * perspective whose association is authored on the root entity (e.g.
+     * EnergyIQ/DistributionSystem --SystemMembers--> members) reaches its members
+     * on the outbound side, so perspective roots may navigate outbound.
+     */
+    private readonly outboundRolesCache;
+    /**
+     * The rtId of the entity tree node each entity item was loaded under
+     * (association group nodes are transparent — they record the entity that owns
+     * the group). Used to suppress the direct parent's back-edge on expand: an
+     * edge traversed downwards (e.g. system --SystemMembers--> member) is the very
+     * same edge the child's opposite-direction auto-discovery finds again, which
+     * would render the parent as its own child's child. Keyed by item object
+     * identity (every fetch builds fresh DTOs), so entries are collected together
+     * with their tree nodes. Roots are never registered and get no exclusion.
+     */
+    private readonly parentEntityRtIds;
     private static readonly ckTypeMetaData;
     fetchChildren(item: TreeItemDataTyped<BrowserItem$3>): Promise<TreeItemDataTyped<BrowserItem$3>[]>;
     /**
-     * Discovers the navigable inbound role groups of an entity from its ACTUAL
-     * inbound edges (associations.definitions), grouped by (roleId, origin CK
-     * type) with exact counts. Labels are enriched from the CK type schema
-     * (friendly inbound navigation property name) when the role is declared on the
-     * type, and otherwise derived from the role id (so orphan roles still get a
-     * readable label).
-     */
-    private discoverEntityInboundRoleGroups;
+     * Discovers the navigable role groups of an entity from its ACTUAL edges
+     * (associations.definitions) in the given direction, grouped by (roleId, other-
+     * end CK type) with exact counts. For INBOUND the other end is the edge origin,
+     * for OUTBOUND it is the edge target (AB#4263 — a perspective root may navigate
+     * outbound, e.g. DistributionSystem --SystemMembers--> members). Labels are
+     * enriched from the CK type schema (friendly navigation property name + base
+     * type) when the role is declared on the type, otherwise derived from the role
+     * id (so orphan roles still get a readable label). Edges whose other end is
+     * `excludeRtId` (the entity's direct tree parent) are skipped, so a group that
+     * only contains the parent's back-edge is dropped entirely and counts never
+     * include it.
+     */
+    private discoverEntityRoleGroups;
     /** Readable fallback label for a role id without a schema navigation name. */
     private deriveRoleLabel;
     /**
@@ -865,12 +963,22 @@ declare class RuntimeBrowserDataSource extends OctoGraphQlHierarchyDataSource<Br
      * schema and cached per type id for the lifetime of this data source.
      */
     private getInboundRoles;
+    /**
+     * Returns the OUTBOUND association roles of a CK type (AB#4263), discovered
+     * from the CK schema and cached per type id. Mirrors getInboundRoles but reads
+     * the `out` roles: for an OUTBOUND role this entity is the association's ORIGIN
+     * side, so the related entities to navigate to are on the TARGET side —
+     * targets(direction: OUTBOUND, ckId: rtTargetCkTypeId).
+     */
+    private getOutboundRoles;
     /** Loads the target entities reachable from an entity through one role. */
     private fetchAssociationTargets;
     /**
      * Builds tree items for runtime entities, de-duplicating by rtId and marking
      * an entity expandable when its CK type defines at least one inbound
-     * association role.
+     * association role. `opts.excludeRtId` drops the direct parent's back-edge
+     * target; `opts.parentRtId` registers the built items' tree parent so their
+     * own expansion can exclude it in turn.
      */
     private buildEntityTreeItems;
     /** Stable tree-node id for an association group node. */
@@ -884,9 +992,10 @@ declare class RuntimeBrowserDataSource extends OctoGraphQlHierarchyDataSource<Br
     fetchRootNodes(): Promise<TreeItemDataTyped<BrowserItem$3>[]>;
     /**
      * Loads all runtime instances of a CK type as the roots of a `Type`
-     * perspective (AB#4263), registering their rtIds so the whitelist applies to
-     * their direct children only. Expandability is schema-based (does the type
-     * declare an inbound role, restricted to the whitelist when set).
+     * perspective (AB#4263), tagging them with the root id prefix so the whitelist
+     * applies to their direct children only. Expandability is schema-based (does the type
+     * declare a role in the perspective's navigation direction, restricted to the
+     * whitelist when set).
      */
     private fetchTypePerspectiveRoots;
     /**
@@ -2700,6 +2809,63 @@ declare class RuntimeBrowserStateService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<RuntimeBrowserStateService>;
 }
 
+/** The per-tenant mapping coverage configuration as loaded for editing. */
+interface MappingCoverageConfig {
+    /** rtId of the singleton, or null when it does not exist yet. */
+    rtId: string | null;
+    /** True when the CK type is installed on the tenant (System.UI >= 2.4.0). */
+    typePresent: boolean;
+    /** CK types whose entities act as source candidates in the Orphan Sources tab. */
+    sourceCandidateCkTypeIds: string[];
+}
+/**
+ * Loads and saves the optional per-tenant `System.UI/MappingCoverageConfiguration`
+ * singleton that carries the source-catalogue CK types for the Mapping Coverage
+ * page's Orphan Sources tab.
+ *
+ * Design notes (mirrors {@link TreeNavigationConfigService}):
+ * - The config entity is OPTIONAL. When the CK type is not installed on the
+ *   tenant (System.UI < 2.4.0) or no instance exists, `loadConfig` reports
+ *   `typePresent`/an empty list and the host can fall back (e.g. to its old
+ *   localStorage persistence) without surfacing an error.
+ * - The singleton field (`systemUIMappingCoverageConfiguration`) only exists in
+ *   the tenant schema when the CK type is installed, so querying it blindly
+ *   would raise a GraphQL validation error (and a user-facing toast). We first
+ *   probe the CK schema with the always-valid `constructionKit.types` query and
+ *   only run the singleton query when the type is present.
+ * - Uses inline `gql` (not codegen) so the feature is decoupled from a schema
+ *   re-introspection that includes the new CK type.
+ * - No session cache: the page loads once per visit / tenant switch, so every
+ *   `loadConfig` goes to the network and there is no reset-on-tenant-switch
+ *   pitfall.
+ */
+declare class MappingCoverageConfigService {
+    private readonly apollo;
+    /**
+     * Loads the singleton. Returns `typePresent: false` (and an empty list) when
+     * the CK type is not installed on the tenant; `rtId: null` when the type is
+     * installed but no instance exists yet.
+     */
+    loadConfig(): Promise<MappingCoverageConfig>;
+    /**
+     * Creates or updates the singleton with the given source CK types. Returns
+     * the singleton rtId.
+     */
+    saveConfig(rtId: string | null, sourceCandidateCkTypeIds: string[]): Promise<string>;
+    /**
+     * Probes whether the `System.UI/MappingCoverageConfiguration` CK type is
+     * installed on the tenant (System.UI >= 2.4.0). Uses the always-valid
+     * `constructionKit.types` query so it never raises a schema validation error.
+     */
+    private probeTypePresent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MappingCoverageConfigService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MappingCoverageConfigService>;
+}
+declare const MAPPING_COVERAGE_CONFIG_CONSTANTS: {
+    CONFIG_CK_TYPE_ID: string;
+    CONFIG_WELL_KNOWN_NAME: string;
+};
+
 /**
  * View model for a DataPointMapping entity with resolved source/target information.
  * Used by the DataMappingOverviewComponent for display in the grid.
@@ -2872,6 +3038,28 @@ interface CoverageValidationDetail {
     missingRequired: string[];
     missingRecommended: string[];
 }
+/**
+ * Descriptor of a synthetic association group node (AB#4262 port): groups all
+ * entities reachable from a parent entity through ONE inbound association role
+ * (e.g. `EnergyIQ/SpaceSensors` → "Sensors (5)"). Its target entities load
+ * lazily on expand. Group nodes are not runtime entities — the detail panel
+ * and mapping CRUD stay disabled for them.
+ */
+interface CoverageGroupNodeInfo {
+    /** Entity the grouped edges belong to (the group's tree parent). */
+    parentRtId: string;
+    parentCkTypeId: string;
+    /** Runtime association role id navigated INBOUND from the parent. */
+    roleId: string;
+    /** CK type used as the `ckId` to load the targets (schema origin base). */
+    targetCkTypeId: string;
+    /**
+     * rtId of the GRANDparent entity — excluded from the group's targets so the
+     * node the user came from does not reappear inside the group (direct-parent
+     * back-edge suppression, relevant under `Type` perspective roots).
+     */
+    excludeRtId?: string;
+}
 /**
  * Payload attached to every tree item in the coverage tree. Stored as the `item`
  * of a `TreeItemDataTyped<CoverageNodePayload>` so the host can render and react.
@@ -2887,6 +3075,12 @@ interface CoverageNodePayload extends CoverageEntityRef {
     validationStatus: CoverageNodeStatus | null;
     /** Full validation detail (missing/present lists) when loaded. */
     validationDetail: CoverageValidationDetail | null;
+    /**
+     * Set when this item is a synthetic association group node instead of a
+     * runtime entity. `rtId` then holds the synthetic tree-node id and
+     * `ckTypeId` is empty — consumers must not treat such an item as an entity.
+     */
+    associationGroup?: CoverageGroupNodeInfo;
 }
 type CoverageTreeItem = TreeItemDataTyped<CoverageNodePayload>;
 /**
@@ -2954,6 +3148,19 @@ interface OrphanCandidate {
     parentPath: OrphanCandidateParent[];
 }
 
+/**
+ * Navigation override applied at the ROOT level when a `Type` tree perspective
+ * (AB#4263) is active: the root's direct children are resolved through the
+ * perspective's primary role/direction (e.g. `EnergyIQ/SystemMembers`,
+ * OUTBOUND) instead of the spatial `childRoleId`. Deeper levels always fall
+ * back to the spatial hierarchy (whitelist-at-root-only, mirroring the
+ * runtime browser). The child CK type filter stays `config.childCkTypeId`
+ * (polymorphic), so perspective members must derive from it.
+ */
+interface CoveragePerspectiveNav {
+    childRoleId: string;
+    childDirection: GraphDirectionDto;
+}
 /**
  * Generic hierarchy data source for the Mapping Coverage Tree.
  *
@@ -2961,15 +3168,53 @@ interface OrphanCandidate {
  * `<mm-tree-view>` instance. The data source resolves child nodes through the
  * configured `childRoleId` / `childCkTypeId` and decorates each item with the
  * number of inbound mappings (via `mappingRoleId`).
+ *
+ * On top of the spatial hierarchy, every entity node auto-discovers its OTHER
+ * inbound association roles from its actual edges (AB#4262 port from the
+ * runtime browser): each such role becomes an expandable group node (e.g.
+ * `Sensors (5)` via `EnergyIQ/SpaceSensors`) whose targets — with their own
+ * mapping counts — load lazily on expand. The mapping roles themselves
+ * (MapsTo/MapsFrom) and the spatial child role are excluded from discovery,
+ * and the optional per-tenant `TreeNavigationConfiguration` overrides
+ * (visible/displayName/sortIndex/grouped/icon) apply exactly as in the
+ * runtime browser.
  */
 declare class MappingCoverageTreeDataSource extends HierarchyDataSourceBase<CoverageNodePayload> {
     private readonly getCoverageNodeGQL;
+    private readonly getEntityAssociationsGQL;
+    private readonly getCkTypeAssociationRolesGQL;
+    private readonly treeNavConfig;
     private _root;
     private _config;
     private _rootMappingCount;
     private _validationMap;
+    private _rootPerspectiveNav;
+    /**
+     * Cache of navigable inbound association roles per CK type id, discovered
+     * lazily from the CK schema. Used to enrich discovered role groups with the
+     * friendly navigation-property label + origin BASE type, and to decide
+     * whether a child entity node is expandable beyond its spatial children.
+     */
+    private readonly inboundRolesCache;
+    /**
+     * The rtId of the entity tree node each entity payload was loaded under
+     * (group nodes are transparent — they record the entity that owns the
+     * group via `CoverageGroupNodeInfo.excludeRtId`). Used to suppress the
+     * direct parent's back-edge on expand: the edge traversed downwards at a
+     * `Type` perspective root (outbound) is the very same edge the child's
+     * inbound auto-discovery finds again, which would render the parent as its
+     * own child's child. Keyed by payload object identity (every fetch builds
+     * fresh payloads), so entries are collected together with their tree nodes.
+     */
+    private readonly parentEntityRtIds;
     setRoot(root: CoverageEntityRef | null): void;
     setConfig(config: MappingCoverageTreeConfig): void;
+    /**
+     * Sets (or clears with null) the root-level navigation override of the
+     * active `Type` perspective. The caller must reload the tree afterwards.
+     */
+    setRootPerspectiveNav(nav: CoveragePerspectiveNav | null): void;
+    getRootPerspectiveNav(): CoveragePerspectiveNav | null;
     /**
      * Inject the validation report (rtId → status detail) loaded from the
      * latest PipelineExecution. Pass an empty map to clear the overlay.
@@ -2987,12 +3232,112 @@ declare class MappingCoverageTreeDataSource extends HierarchyDataSourceBase<Cove
      * collapsing the surrounding subtree.
      */
     refreshNode(rtId: string, ckTypeId: string): Promise<CoverageNodePayload | null>;
+    /**
+     * Builds the auto-discovered (non-spatial) part of an entity's child level:
+     * one group node per inbound role found on its actual edges, plus the
+     * flattened targets of roles a TreeNavigationConfiguration override marks as
+     * `grouped: false`. Roles hidden by an override are dropped.
+     */
+    private buildDiscoveredNodes;
+    /**
+     * Discovers the navigable inbound role groups of an entity from its ACTUAL
+     * edges (associations.definitions), grouped by roleId with exact counts.
+     * This mirrors the runtime browser's AB#4262 discovery: real edges also
+     * surface orphan roles (edge exists but the role is no longer declared on
+     * the type in the installed CK model). Labels + the origin BASE type come
+     * from the CK type schema when available; orphan roles fall back to the
+     * concrete edge origin and a label derived from the role id.
+     *
+     * The spatial child role and the mapping roles (MapsTo/MapsFrom — rendered
+     * in the detail panel, not the tree) are excluded, as are edges from the
+     * direct tree parent (`excludeRtId`, back-edge suppression).
+     */
+    private discoverRoleGroups;
+    /**
+     * Association role ids never offered as tree navigation: the spatial child
+     * role (already flattened into the hierarchy), the mapping roles (their
+     * edges ARE the mapping counts / detail panel content) and the
+     * pipeline-execution role.
+     */
+    private excludedNavigationRoleIds;
+    /**
+     * Returns the navigable inbound association roles of a CK type, discovered
+     * from the CK schema and cached per type id for the lifetime of this data
+     * source. Uses the RUNTIME ids from the backend (`rtRoleId`,
+     * `rtOriginCkTypeId`), never the versioned fullName — for an INBOUND role
+     * this entity is the association's TARGET side, so the related entities are
+     * on the ORIGIN side.
+     */
+    private getInboundRoles;
+    /**
+     * Whether entities of the given type can have discoverable children beyond
+     * the spatial hierarchy — i.e. the type declares at least one non-excluded
+     * inbound role. Schema-based, so an expand arrow may open to an empty set
+     * for an instance without edges (acceptable; mirrors the runtime browser).
+     */
+    private typeHasNavigableInboundRoles;
+    /**
+     * Builds tree items for entity children, de-duplicating by rtId and dropping
+     * the direct parent's back-edge target (`excludeRtId`). An entity is marked
+     * expandable when it has spatial grandchildren OR its CK type declares a
+     * navigable inbound role. `parentRtId` registers each item's tree parent so
+     * its own expansion can exclude it in turn.
+     */
+    private buildEntityItems;
+    /** Builds the synthetic tree item for one discovered association role group. */
+    private buildGroupItem;
     private buildItem;
     private queryNode;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MappingCoverageTreeDataSource, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MappingCoverageTreeDataSource>;
 }
 
+/**
+ * Pure helpers for the mapping-expression live preview shown in the mapping
+ * edit dialogs: "value = <current source value> → <expression result>".
+ *
+ * The evaluator itself is provided by the HOST (Refinery Studio wires
+ * `ExpressionEvaluatorService` from `@meshmakers/octo-process-diagrams`) — the
+ * library stays evaluator-agnostic, mirroring the `expressionValidator` input
+ * pattern of `DataMappingListComponent`. Note the evaluation is a CLIENT-SIDE
+ * APPROXIMATION (expr-eval) of the backend's mXparser semantics; simple
+ * arithmetic/comparison/ternary expressions behave identically.
+ */
+/** Result of evaluating a mapping expression against a concrete value. */
+interface MappingExpressionPreviewResult {
+    valid: boolean;
+    error?: string;
+    preview?: string;
+}
+/**
+ * Host-provided evaluator: applies `expression` with the given `value` bound
+ * to the `value` variable and returns the formatted result.
+ */
+type MappingExpressionEvaluatorFn = (expression: string, value: unknown) => MappingExpressionPreviewResult;
+/**
+ * Coerces a raw data-point value (often a string on the wire, e.g. "21.5" or
+ * "true") into the type the expression should see — mirroring how the backend
+ * feeds numeric state values into mXparser.
+ */
+declare function coerceDataPointValue(raw: unknown): unknown;
+/** The computed preview line for the dialog. */
+interface ExpressionPreview {
+    /** The raw source value shown as "value = …". */
+    valueLabel: string;
+    /** True when no expression is set — the value passes through unchanged. */
+    passThrough: boolean;
+    /**
+     * Evaluation result, or null when an expression is set but the host
+     * provided no evaluator (only the source value can be shown then).
+     */
+    result: MappingExpressionPreviewResult | null;
+}
+/**
+ * Computes the preview line, or null when the source's current value is
+ * unknown (nothing sensible to show).
+ */
+declare function computeExpressionPreview(evaluator: MappingExpressionEvaluatorFn | null | undefined, expression: string | null | undefined, rawValue: unknown): ExpressionPreview | null;
+
 interface RootCandidate {
     rtId: string;
     ckTypeId: string;
@@ -3003,18 +3348,57 @@ interface PipelineCandidate {
     rtId: string;
     ckTypeId: string;
     name: string;
+    /**
+     * Raw PipelineDefinition YAML (when the list query returned it). Used to
+     * auto-detect the mapping backup pipelines by their node types
+     * (ExportDataPointMappings@ / ImportDataPointMappings@) so the Export/Import
+     * actions need no manual pipeline picking.
+     */
+    definition: string | null;
 }
 /**
- * A bucket of orphan candidates sharing the same immediate parent. Produced
- * by `orphanGroupedList` when the "group by parent" toggle is on.
+ * Statistics object emitted by the ImportDataPointMappings@1 node (its
+ * `statisticsTargetPath` output, returned via SetPipelineExecutionResult).
+ * Mirrors the node's ImportStatistics record.
+ */
+interface ImportStatistics {
+    total?: number;
+    resolved?: number;
+    unresolved?: number;
+    unresolvedEntries?: {
+        name?: string;
+        reason?: string;
+    }[];
+}
+/**
+ * A bucket of orphan candidates sharing the same parent NAME (not instance).
+ * Produced by `orphanGroupedList` when the "group by parent" toggle is on.
+ * Keying on the name merges same-named parents into one section — e.g. the
+ * Loxone/Category "Beleuchtung" exists once per room as its own rtId, but the
+ * user thinks of it as ONE category.
  */
 interface OrphanGroup {
-    /** Stable key — parent's CkTypeId@RtId, or `__no_parent__` for the catch-all bucket. */
+    /** Stable key — the parent's name, or `__no_parent__` for the catch-all bucket. */
     key: string;
     /** Human-readable label rendered as the section heading. */
     label: string;
     items: OrphanCandidate[];
 }
+/**
+ * Statistics object emitted by the GenerateDataPointMappings@1 node (its
+ * `statisticsTargetPath` output, stored into PipelineExecution.OutputData via
+ * SetPipelineExecutionResult). All fields optional — the UI shows whatever the
+ * pipeline provided and falls back to a plain "completed" note otherwise.
+ */
+interface GenerationStatistics {
+    totalContainers?: number;
+    matchedContainers?: number;
+    unmatchedContainers?: number;
+    unmatchedContainerNames?: string[];
+    totalSuggestions?: number;
+    ruleHits?: Record<string, number>;
+    definedRuleIds?: string[];
+}
 /**
  * Master-detail component that visualises mapping coverage on a generic entity
  * hierarchy (defaults: Basic/Tree + Basic/TreeNode, mappings via
@@ -3024,9 +3408,11 @@ interface OrphanGroup {
  * Phase 1: tree + counts + read-only mapping list + CRUD (add new mapping,
  * relink source via {@link EntitySelectorDialogService}, delete).
  */
-declare class MappingCoverageTreeComponent implements OnInit {
+declare class MappingCoverageTreeComponent implements OnInit, OnChanges {
     private readonly entitySelector;
+    private readonly treeNavConfig;
     private readonly editDialog;
+    private readonly bulkDialog;
     private readonly confirmation;
     private readonly communicationService;
     private readonly getEntitiesByCkType;
@@ -3050,6 +3436,13 @@ declare class MappingCoverageTreeComponent implements OnInit {
      * the pipeline externally.
      */
     tenantId: string | null;
+    /**
+     * Optional host-provided expression evaluator (e.g. expr-eval via
+     * `@meshmakers/octo-process-diagrams`' ExpressionEvaluatorService). When
+     * set, the mapping edit dialogs show a live preview of the expression
+     * applied to the source data point's current value.
+     */
+    expressionEvaluator: MappingExpressionEvaluatorFn | null;
     readonly entitySelected: EventEmitter<CoverageEntityRef>;
     protected readonly icons: {
         refresh: _progress_kendo_svg_icons.SVGIcon;
@@ -3058,7 +3451,18 @@ declare class MappingCoverageTreeComponent implements OnInit {
         pencil: _progress_kendo_svg_icons.SVGIcon;
         trash: _progress_kendo_svg_icons.SVGIcon;
         link: _progress_kendo_svg_icons.SVGIcon;
+        x: _progress_kendo_svg_icons.SVGIcon;
+        download: _progress_kendo_svg_icons.SVGIcon;
+        upload: _progress_kendo_svg_icons.SVGIcon;
     };
+    /** Selectable tree perspectives (built-in Spatial + per-tenant configured). */
+    protected readonly perspectives: _angular_core.WritableSignal<PerspectiveDefinition[]>;
+    protected readonly activePerspectiveKey: _angular_core.WritableSignal<string>;
+    /**
+     * CK type whose instances populate the root dropdown: the active `Type`
+     * perspective's rootCkTypeId, or the config default for Spatial.
+     */
+    protected readonly activeRootCkTypeId: _angular_core.Signal<string>;
     protected readonly rootCandidates: _angular_core.WritableSignal<RootCandidate[]>;
     protected readonly selectedRoot: _angular_core.WritableSignal<RootCandidate | null>;
     protected readonly selectedNode: _angular_core.WritableSignal<CoverageNodePayload | null>;
@@ -3072,6 +3476,24 @@ declare class MappingCoverageTreeComponent implements OnInit {
     protected readonly validationLoading: _angular_core.WritableSignal<boolean>;
     protected readonly validationError: _angular_core.WritableSignal<string | null>;
     protected readonly validationRunning: _angular_core.WritableSignal<boolean>;
+    /** Generation: run a GenerateDataPointMappings-based pipeline from the UI. */
+    protected readonly selectedGenerationPipeline: _angular_core.WritableSignal<PipelineCandidate | null>;
+    protected readonly generationRunning: _angular_core.WritableSignal<boolean>;
+    protected readonly generationError: _angular_core.WritableSignal<string | null>;
+    protected readonly generationStats: _angular_core.WritableSignal<GenerationStatistics | null>;
+    protected readonly generationCompletedAt: _angular_core.WritableSignal<string | null>;
+    /**
+     * Backup: export/import DataPointMappings via the mapping-backup pipelines
+     * (ExportDataPointMappings@1 / ImportDataPointMappings@1 nodes). The
+     * pipelines are auto-detected from the loaded pipeline definitions; the
+     * Backup toolbar row only shows when at least one is deployed.
+     */
+    protected readonly exportBackupPipeline: _angular_core.Signal<PipelineCandidate | null>;
+    protected readonly importBackupPipeline: _angular_core.Signal<PipelineCandidate | null>;
+    protected readonly backupRunning: _angular_core.WritableSignal<"export" | "import" | null>;
+    protected readonly backupError: _angular_core.WritableSignal<string | null>;
+    protected readonly importStats: _angular_core.WritableSignal<ImportStatistics | null>;
+    protected readonly importCompletedAt: _angular_core.WritableSignal<string | null>;
     /** Active tab: 'coverage' shows the tree, 'orphans' shows the unmapped sources. */
     protected readonly activeTab: _angular_core.WritableSignal<"coverage" | "orphans">;
     /** Source CK type currently inspected for orphans. */
@@ -3080,7 +3502,12 @@ declare class MappingCoverageTreeComponent implements OnInit {
     protected readonly orphanLoading: _angular_core.WritableSignal<boolean>;
     protected readonly orphanError: _angular_core.WritableSignal<string | null>;
     protected readonly orphanHideMapped: _angular_core.WritableSignal<boolean>;
+    /** Full-text filter over the loaded orphan catalogue (client-side). */
+    protected readonly orphanSearchText: _angular_core.WritableSignal<string>;
     protected readonly orphanFilteredList: _angular_core.Signal<OrphanCandidate[]>;
+    /** rtIds of the orphan rows selected for the bulk "Map selected…" action. */
+    protected readonly orphanSelectedIds: _angular_core.WritableSignal<ReadonlySet<string>>;
+    protected readonly orphanSelectedCount: _angular_core.Signal<number>;
     protected readonly orphanStats: _angular_core.Signal<{
         total: number;
         unmapped: number;
@@ -3089,13 +3516,33 @@ declare class MappingCoverageTreeComponent implements OnInit {
     /**
      * Which parent CK type to group by, or null for a flat list. We let the user
      * pick the type instead of just "immediate parent" because Loxone-style trees
-     * include intermediate buckets (Loxone/Category) where each parent rtId is
-     * unique per room — grouping by Category produces dozens of look-alike
-     * sections ("Stellantrieb" appears N times, once per room). The user almost
-     * always wants Loxone/Room or whichever level genuinely partitions the data,
-     * so we expose all parent types seen in the loaded data and let them choose.
+     * include intermediate buckets (Loxone/Category) alongside the spatial level
+     * (Loxone/Room); which one meaningfully partitions the data depends on the
+     * task, so we expose all parent types seen in the loaded data and let them
+     * choose. Groups are merged by parent NAME (see {@link orphanGroupedList}),
+     * so per-room duplicates of the same category collapse into one section.
      */
     protected readonly orphanGroupParentType: _angular_core.WritableSignal<string | null>;
+    /**
+     * Multi-select filter over the group names of the active grouping type —
+     * e.g. show only the "Beleuchtung" and "Klima" categories. Empty = no
+     * filter. Cleared whenever the grouping type or the source type changes.
+     */
+    protected readonly orphanSelectedGroupNames: _angular_core.WritableSignal<string[]>;
+    /**
+     * Distinct group names available for the active grouping type, offered as
+     * options in the group-name filter. Derived from ALL loaded candidates (not
+     * the filtered list) so the option set stays stable while filters are
+     * applied. The catch-all "(no parent…)" label sorts last.
+     */
+    protected readonly orphanAvailableGroupNames: _angular_core.Signal<string[]>;
+    /**
+     * The rows actually rendered (flat or grouped): the text/mapped filter
+     * narrowed further by the group-name multi-select. Select-all and the
+     * "N shown" badge operate on this list so bulk actions match what the user
+     * sees.
+     */
+    protected readonly orphanVisibleList: _angular_core.Signal<OrphanCandidate[]>;
     /**
      * Distinct parent CK type ids found in the loaded candidates, sorted so the
      * deepest type (root-most ancestor) comes first. For Loxone-Controls this is
@@ -3106,6 +3553,29 @@ declare class MappingCoverageTreeComponent implements OnInit {
     protected readonly orphanGroupedList: _angular_core.Signal<OrphanGroup[]>;
     protected readonly summaryLine: _angular_core.Signal<string | null>;
     ngOnInit(): Promise<void>;
+    /**
+     * The Studio loads the per-tenant source-candidate CK types ASYNCHRONOUSLY
+     * (System.UI singleton) and re-emits the `config` input when they arrive —
+     * after this component's ngOnInit already ran with an empty list. Pick up
+     * the late config here: refresh the data source and initialise the orphan
+     * tab's type selection once, loading the catalogue immediately when the
+     * tab is already active (otherwise it silently stays empty).
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Loads the per-tenant tree perspectives (AB#4263) shared with the runtime
+     * browser via {@link TreeNavigationConfigService} and prepends the built-in
+     * Spatial one, de-duplicated by key (a configured `Spatial` overrides the
+     * built-in). Failures degrade to the built-in perspective only.
+     */
+    private loadPerspectives;
+    /**
+     * Switches the active perspective: applies the root-level navigation
+     * override on the data source (primary role + direction for `Type`
+     * perspectives), clears the current selection and reloads the root
+     * candidates from the perspective's root CK type.
+     */
+    protected onPerspectiveChange(key: string): Promise<void>;
     protected onPipelineSelectChange(rtId: string): void;
     protected refreshValidation(): Promise<void>;
     protected clearValidation(): void;
@@ -3114,6 +3584,7 @@ declare class MappingCoverageTreeComponent implements OnInit {
     protected refreshOrphans(): Promise<void>;
     protected toggleOrphanHideMapped(): void;
     protected onOrphanGroupParentTypeChange(value: string): void;
+    protected onOrphanGroupNamesChange(names: string[]): void;
     /**
      * Returns the parent chain ordered for breadcrumb display: root-most ancestor
      * first, immediate parent last. `parentPath` itself is stored immediate-first
@@ -3126,6 +3597,10 @@ declare class MappingCoverageTreeComponent implements OnInit {
      * its inbound MapsFrom DataPointMapping count. The view filters the list
      * down to mappingCount === 0 by default, but the user can flip the toggle
      * to see all candidates (mapped + unmapped) for verification.
+     *
+     * Pages through the connection cursor until `hasNextPage` is false so
+     * catalogues larger than one page are loaded completely (an earlier
+     * version fetched a single 1000-row page and silently truncated).
      */
     private loadOrphanCandidates;
     /**
@@ -3136,16 +3611,83 @@ declare class MappingCoverageTreeComponent implements OnInit {
      */
     protected createMappingFromOrphan(orphan: OrphanCandidate): Promise<void>;
     protected trackOrphanByRtId(_index: number, item: OrphanCandidate): string;
+    protected isOrphanSelected(rtId: string): boolean;
+    protected toggleOrphanSelected(rtId: string): void;
+    /** Selects every row currently visible under the active filter. */
+    protected selectAllVisibleOrphans(): void;
+    protected clearOrphanSelection(): void;
+    /**
+     * Opens the bulk mapping dialog for all selected orphan rows and, on
+     * confirm, creates one DataPointMapping per source in a single atomic
+     * CreateEntities mutation (shared target entity + paths + expression,
+     * per-source MapsFrom association and generated name).
+     */
+    protected bulkMapSelected(): Promise<void>;
     /**
      * Triggers the selected validation pipeline on the Communication Controller
      * and, when it completes, automatically refreshes the coverage report so the
      * tree colour-codes update. Requires {@link tenantId} to be set.
-     *
-     * Polling strategy: every 1.5 s, fetch the latest execution metadata for the
-     * pipeline. When `dateTime` differs from the snapshot taken before the run,
-     * we know a new execution finished — refresh and stop. Aborts after 60 s.
      */
     protected runValidation(): Promise<void>;
+    /**
+     * Triggers the selected mapping-generation pipeline (GenerateDataPointMappings-
+     * based auto-mapping) and, on completion, loads its statistics from the
+     * execution's OutputData and refreshes the tree, the selected node's mapping
+     * list and the orphan catalogue — all of which change when mappings are
+     * created in bulk. Requires {@link tenantId} to be set.
+     */
+    protected runGeneration(): Promise<void>;
+    protected onGenerationSelectChange(rtId: string): void;
+    /**
+     * Loads the latest execution's OutputData for the generation pipeline and
+     * parses the GenerateDataPointMappings statistics from it (the pipeline is
+     * expected to end with SetPipelineExecutionResult on its statisticsTargetPath).
+     * Missing/foreign OutputData degrades to "completed without statistics".
+     */
+    private loadGenerationResult;
+    /**
+     * Loads the latest execution's OutputData + CompletedAt for any pipeline
+     * (shared by the generation statistics and the backup export/import flows).
+     */
+    private loadLatestExecutionOutput;
+    /**
+     * Runs the auto-detected export pipeline (ExportDataPointMappings@1) via the
+     * Communication Controller and offers the execution's OutputData — the
+     * portable mapping export document — as a JSON file download.
+     */
+    protected exportMappings(): Promise<void>;
+    /**
+     * Handles the hidden file input: parses the selected export document and
+     * runs the auto-detected import pipeline (ImportDataPointMappings@1) with
+     * `{ body: document }` as the pipeline input — the same shape the pipeline's
+     * HTTP POST trigger produces, so one definition serves both entry points.
+     * On completion the import statistics (resolved/unresolved) are shown and
+     * the tree, mapping list and orphan catalogue reload.
+     */
+    protected onImportFileSelected(event: Event): Promise<void>;
+    /** Tooltip text for the "unresolved" badge — first 10 entry names + reason. */
+    protected unresolvedImportNames(): string;
+    /**
+     * Offers a string as a JSON file download. Kept as a small overridable seam
+     * so tests can intercept the browser download plumbing.
+     */
+    protected saveJsonFile(content: string, fileName: string): void;
+    /**
+     * Executes a pipeline on the Communication Controller and polls until a NEW
+     * execution leaves the Running state.
+     *
+     * Polling strategy: snapshot the latest execution's id first; then every
+     * 1.5 s fetch the latest execution metadata. When the id differs from the
+     * snapshot AND the status is not Running, the run finished. Treats absent
+     * status as "done": the in-memory debug-cache branch of
+     * GET /pipelineDebug/.../latest doesn't populate Status (only the MongoDB
+     * fallback does), so a sub-second pipeline that hits the cache path before
+     * the DB row is visible would never satisfy a strict `status === 'Completed'`
+     * check and the button would freeze. We only keep polling while the
+     * controller *explicitly* reports "Running" (case-insensitive). Aborts after
+     * 60 s ('timeout').
+     */
+    private executePipelineAndAwaitCompletion;
     private refreshTreeOverlay;
     private loadValidationPipelines;
     protected refreshRoots(): Promise<void>;
@@ -3176,7 +3718,7 @@ declare class MappingCoverageTreeComponent implements OnInit {
      */
     private resolveSourceNames;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MappingCoverageTreeComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MappingCoverageTreeComponent, "mm-mapping-coverage-tree", never, { "config": { "alias": "config"; "required": false; }; "initialRoot": { "alias": "initialRoot"; "required": false; }; "tenantId": { "alias": "tenantId"; "required": false; }; }, { "entitySelected": "entitySelected"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MappingCoverageTreeComponent, "mm-mapping-coverage-tree", never, { "config": { "alias": "config"; "required": false; }; "initialRoot": { "alias": "initialRoot"; "required": false; }; "tenantId": { "alias": "tenantId"; "required": false; }; "expressionEvaluator": { "alias": "expressionEvaluator"; "required": false; }; }, { "entitySelected": "entitySelected"; }, never, never, true, never>;
 }
 
 /**
@@ -3216,6 +3758,12 @@ interface MappingEditValue {
 interface MappingEditDialogData {
     mapping: MappingEditValue;
     title?: string;
+    /**
+     * Optional host-provided expression evaluator. When set, the dialog shows a
+     * live preview of the mapping expression applied to the selected source
+     * data point's current value.
+     */
+    expressionEvaluator?: MappingExpressionEvaluatorFn;
     /**
      * Default CK type id for the Target Attribute Path autocomplete when the
      * mapping has no target picked yet. Once the user picks a target entity,
@@ -3265,6 +3813,14 @@ declare class MappingEditDialogComponent {
      * legacy default. Drives the Target Attribute Path autocomplete dropdown.
      */
     protected readonly effectiveTargetCkTypeId: _angular_core.Signal<string | undefined>;
+    /** The source data-point picker; carries the selected point's current value. */
+    private readonly sourcePicker;
+    /**
+     * Live "value = X → Y" preview of the mapping expression applied to the
+     * selected source data point's last known value. Null when the value is
+     * unknown; the evaluation itself requires a host-provided evaluator.
+     */
+    protected readonly expressionPreview: _angular_core.Signal<_meshmakers_octo_ui.ExpressionPreview | null>;
     initialise(data: MappingEditDialogData): void;
     /**
      * Enabled when at least one labelled side of the mapping is filled enough
@@ -3286,6 +3842,7 @@ declare class MappingEditDialogComponent {
     protected pickSource(): Promise<void>;
     protected pickTarget(): Promise<void>;
     protected onSourceAttributePathChange(value: string): void;
+    protected onExpressionChange(value: string): void;
     protected onTargetAttributePathChange(value: string | null): void;
     protected onTargetAttributeFilter(filter: string): void;
     protected onSave(): void;
@@ -3324,6 +3881,101 @@ declare class MappingEditDialogService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MappingEditDialogService>;
 }
 
+/**
+ * Shared settings applied to every mapping created by the bulk flow: one
+ * target entity plus one source data point / target attribute / expression for
+ * all selected sources. Per-source values (the MapsFrom association and the
+ * generated name) are derived by the caller.
+ */
+interface BulkMappingValue {
+    targetRtId: string;
+    targetCkTypeId: string;
+    targetName?: string;
+    sourceAttributePath: string;
+    targetAttributePath: string;
+    mappingExpression: string;
+    enabled: boolean;
+}
+interface BulkMappingDialogData {
+    /** The selected source entities (orphan-tab multi-select). */
+    sources: CoverageEntityRef[];
+    title?: string;
+    /**
+     * Optional host-provided expression evaluator. When set, the dialog shows a
+     * live preview of the mapping expression applied to the FIRST selected
+     * source's current data-point value.
+     */
+    expressionEvaluator?: MappingExpressionEvaluatorFn;
+}
+type BulkMappingDialogResult = {
+    confirmed: true;
+    value: BulkMappingValue;
+} | {
+    confirmed: false;
+};
+/**
+ * Bulk variant of the mapping editor: creates the SAME mapping shape (source
+ * data point → target attribute, one shared target entity) for N selected
+ * source entities in one go. The source data-point options are loaded from the
+ * FIRST selected source — the usual bulk case is a set of same-typed controls
+ * exposing identical states; free text stays possible for mixed sets.
+ */
+declare class BulkMappingDialogComponent {
+    private readonly windowRef;
+    private readonly entitySelector;
+    private readonly attributeSelectorDialog;
+    private readonly attributeService;
+    protected readonly browseIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly sources: _angular_core.WritableSignal<CoverageEntityRef[]>;
+    protected readonly firstSource: _angular_core.Signal<CoverageEntityRef>;
+    protected readonly sourcePreview: _angular_core.Signal<string>;
+    protected enabled: boolean;
+    protected readonly sourceAttributePath: _angular_core.WritableSignal<string>;
+    protected readonly mappingExpression: _angular_core.WritableSignal<string>;
+    protected readonly targetRtId: _angular_core.WritableSignal<string | null>;
+    protected readonly targetCkTypeId: _angular_core.WritableSignal<string | null>;
+    protected readonly targetName: _angular_core.WritableSignal<string | null>;
+    protected readonly targetAttributePath: _angular_core.WritableSignal<string>;
+    private readonly targetAttributes;
+    protected readonly targetFilter: _angular_core.WritableSignal<string>;
+    protected readonly targetAttributesLoading: _angular_core.WritableSignal<boolean>;
+    /** The source data-point picker; carries the selected point's current value. */
+    private readonly sourcePicker;
+    /** Optional host-provided evaluator (set via initialise). */
+    private expressionEvaluator;
+    /**
+     * Live "value = X → Y" preview of the shared mapping expression applied to
+     * the FIRST selected source's data-point value (the usual bulk case is a
+     * set of same-typed controls, so the first one is representative).
+     */
+    protected readonly expressionPreview: _angular_core.Signal<_meshmakers_octo_ui.ExpressionPreview | null>;
+    protected readonly targetAttributeList: _angular_core.Signal<AttributeItem[]>;
+    initialise(data: BulkMappingDialogData): void;
+    protected isValid(): boolean;
+    protected pickTarget(): Promise<void>;
+    protected onTargetAttributePathChange(value: string | null): void;
+    protected browseTargetAttribute(): Promise<void>;
+    protected onSave(): void;
+    protected onCancel(): void;
+    /** Direct CK attributes of the target type for the combobox (same rules as the single-mapping editor). */
+    private loadTargetAttributes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BulkMappingDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BulkMappingDialogComponent, "mm-bulk-mapping-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class BulkMappingDialogService {
+    private readonly windowService;
+    private readonly windowStateService;
+    /**
+     * Opens the bulk mapping editor for the given source entities and returns
+     * the shared mapping settings on confirm. The host creates the actual
+     * mapping entities (one per source) — the dialog only collects the values.
+     */
+    open(data: BulkMappingDialogData): Promise<BulkMappingDialogResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BulkMappingDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BulkMappingDialogService>;
+}
+
 /**
  * Input data for the RuntimeEntityVariableDialog.
  */
@@ -3442,5 +4094,5 @@ declare class TenantSwitcherComponent {
  */
 declare function provideOctoUi(): EnvironmentProviders;
 
-export { AssociationValidationService, AttributeSelectorDialogComponent, AttributeSelectorDialogService, AttributeSortSelectorDialogComponent, AttributeSortSelectorDialogService, AttributeValueTypeDto, CkTypeSelectorDialogComponent, CkTypeSelectorDialogService, CkTypeSelectorInputComponent, DEFAULT_CK_TYPE_SELECTOR_DIALOG_MESSAGES, DEFAULT_CK_TYPE_SELECTOR_INPUT_MESSAGES, DEFAULT_DATA_POINT, DEFAULT_MAPPING_COVERAGE_TREE_CONFIG, DEFAULT_PROPERTY_GRID_MESSAGES, DEFAULT_RUNTIME_BROWSER_MESSAGES, DataMappingOverviewComponent, DataPointPickerComponent, DataPointResolverService, DefaultPropertyCategory, EntityDetailComponent, EntityIdInfoComponent, EntitySelectorDialogComponent, EntitySelectorDialogService, FieldFilterEditorComponent, MappingCoverageTreeComponent, MappingCoverageTreeDataSource, MappingEditDialogComponent, MappingEditDialogService, OctoGraphQlDataSource, OctoGraphQlHierarchyDataSource, OctoLoaderComponent, PropertyConverterService, PropertyDisplayMode, PropertyGridComponent, PropertyValueDisplayComponent, RUNTIME_BROWSER_MESSAGES, RecordDetailDialogComponent, RtEntityIdHelper, RuntimeBrowserComponent, RuntimeBrowserOutletComponent, RuntimeBrowserPageComponent, RuntimeBrowserStateService, RuntimeEntityVariableDialogComponent, RuntimeEntityVariableDialogService, TREE_NAVIGATION_CONFIG_CONSTANTS, TenantSwitcherComponent, TreeNavigationConfigService, account_tree, add, analytics, app_registration, article, botService, category, chat, checklist, code, component_exchange, computer, createRuntimeBrowserRoutes, customer, dashboard, event_list, extractDataPointNames, graphic_eq, group, identityService, insert_link, manage_accounts, more_time, notifications, page_info, pages, person_search, playlist_add_check, pool, power, provideOctoUi, publicIcon, query_builder, schedule_send, settings, sort, storage, swagger, swagger_asset, swagger_bot, swagger_communication, swagger_identity, team_dashboard, tenancy, text_snippet, travel_explore, user_diagnostics, webhook, work };
-export type { AttributeItemLike, AttributeSelectorDialogData, AttributeSelectorDialogResult, AttributeSelectorResult, AttributeSortItem, AttributeSortSelectorDialogData, AttributeSortSelectorDialogResult, AttributeSortSelectorResult, BinaryDownloadEvent, BrowserItem, BrowserState, CkAssociationRole, CkTypeSelectorDialogData, CkTypeSelectorDialogMessages, CkTypeSelectorDialogResult, CkTypeSelectorInputMessages, CkTypeSelectorResult, CoverageEntityRef, CoverageMappingItem, CoverageNodePayload, CoverageTreeIcons, CoverageTreeItem, DataPointMappingItem, DataPointMappingOverviewItem, EntitySelectorDialogData, EntitySelectorDialogResult, EntitySelectorResult, ExpressionValidationResult, ExpressionValidatorFn, FieldFilterItem, FilterVariable, MappingCoverageTreeConfig, MappingEditDialogData, MappingEditDialogResult, MappingEditValue, MappingOverviewSummary, MoveValidationResult, PerspectiveDefinition, PerspectiveDirection, PerspectiveRootMode, PropertyChangeEvent, PropertyGridConfig, PropertyGridItem, PropertyGridMessages, RtEntityId, RuntimeBrowserMessages, RuntimeBrowserRouteOptions, RuntimeEntityVariableDialogData, RuntimeEntityVariableDialogResult, RuntimeEntityVariableMapping, RuntimeEntityVariableResult, SortOption, TreeNavigationConfig, TreeNavigationRoleConfig, TreeNavigationRoleOverride, ValidationMessage };
+export { AssociationValidationService, AttributeSelectorDialogComponent, AttributeSelectorDialogService, AttributeSortSelectorDialogComponent, AttributeSortSelectorDialogService, AttributeValueTypeDto, BulkMappingDialogComponent, BulkMappingDialogService, CkTypeSelectorDialogComponent, CkTypeSelectorDialogService, CkTypeSelectorInputComponent, DEFAULT_CK_TYPE_SELECTOR_DIALOG_MESSAGES, DEFAULT_CK_TYPE_SELECTOR_INPUT_MESSAGES, DEFAULT_DATA_POINT, DEFAULT_MAPPING_COVERAGE_TREE_CONFIG, DEFAULT_PROPERTY_GRID_MESSAGES, DEFAULT_RUNTIME_BROWSER_MESSAGES, DataMappingOverviewComponent, DataPointPickerComponent, DataPointResolverService, DefaultPropertyCategory, EntityDetailComponent, EntityIdInfoComponent, EntitySelectorDialogComponent, EntitySelectorDialogService, FieldFilterEditorComponent, MAPPING_COVERAGE_CONFIG_CONSTANTS, MappingCoverageConfigService, MappingCoverageTreeComponent, MappingCoverageTreeDataSource, MappingEditDialogComponent, MappingEditDialogService, OctoGraphQlDataSource, OctoGraphQlHierarchyDataSource, OctoLoaderComponent, PropertyConverterService, PropertyDisplayMode, PropertyGridComponent, PropertyValueDisplayComponent, RUNTIME_BROWSER_MESSAGES, RecordDetailDialogComponent, RtEntityIdHelper, RuntimeBrowserComponent, RuntimeBrowserOutletComponent, RuntimeBrowserPageComponent, RuntimeBrowserStateService, RuntimeEntityVariableDialogComponent, RuntimeEntityVariableDialogService, TREE_NAVIGATION_CONFIG_CONSTANTS, TenantSwitcherComponent, TreeNavigationConfigService, account_tree, add, analytics, app_registration, article, botService, category, chat, checklist, code, coerceDataPointValue, component_exchange, computeExpressionPreview, computer, createRuntimeBrowserRoutes, customer, dashboard, event_list, extractDataPointNames, extractDataPoints, graphic_eq, group, identityService, insert_link, manage_accounts, more_time, notifications, page_info, pages, person_search, playlist_add_check, pool, power, provideOctoUi, publicIcon, query_builder, schedule_send, settings, sort, storage, swagger, swagger_asset, swagger_bot, swagger_communication, swagger_identity, team_dashboard, tenancy, text_snippet, travel_explore, user_diagnostics, webhook, work };
+export type { AttributeItemLike, AttributeSelectorDialogData, AttributeSelectorDialogResult, AttributeSelectorResult, AttributeSortItem, AttributeSortSelectorDialogData, AttributeSortSelectorDialogResult, AttributeSortSelectorResult, BinaryDownloadEvent, BrowserItem, BrowserState, BulkMappingDialogData, BulkMappingDialogResult, BulkMappingValue, CkAssociationRole, CkTypeSelectorDialogData, CkTypeSelectorDialogMessages, CkTypeSelectorDialogResult, CkTypeSelectorInputMessages, CkTypeSelectorResult, CoverageEntityRef, CoverageMappingItem, CoverageNodePayload, CoverageTreeIcons, CoverageTreeItem, DataPointInfo, DataPointMappingItem, DataPointMappingOverviewItem, EntitySelectorDialogData, EntitySelectorDialogResult, EntitySelectorResult, ExpressionPreview, ExpressionValidationResult, ExpressionValidatorFn, FieldFilterItem, FilterVariable, MappingCoverageConfig, MappingCoverageTreeConfig, MappingEditDialogData, MappingEditDialogResult, MappingEditValue, MappingExpressionEvaluatorFn, MappingExpressionPreviewResult, MappingOverviewSummary, MoveValidationResult, PerspectiveDefinition, PerspectiveDirection, PerspectiveRootMode, PropertyChangeEvent, PropertyGridConfig, PropertyGridItem, PropertyGridMessages, RtEntityId, RuntimeBrowserMessages, RuntimeBrowserRouteOptions, RuntimeEntityVariableDialogData, RuntimeEntityVariableDialogResult, RuntimeEntityVariableMapping, RuntimeEntityVariableResult, SortOption, TreeNavigationConfig, TreeNavigationRoleConfig, TreeNavigationRoleOverride, ValidationMessage };