@meshmakers/octo-meshboard 3.5.500 → 3.5.520

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

@@ -7,7 +7,7 @@ import { SortDto, FieldFilterDto, QueryModeDto, ResolveSeriesQueryInputDto, CkRo
 export { RuntimeEntityDialogDataSource, RuntimeEntityItem, RuntimeEntitySelectDataSource, TENANT_ID_PROVIDER, TenantIdProvider } from '@meshmakers/octo-services';
 import { ControlValueAccessor } from '@angular/forms';
 import * as i1 from '@meshmakers/shared-ui';
-import { EntitySelectDialogDataSource, ColumnDefinition, DialogFetchOptions, DialogFetchResult, EntitySelectInputComponent, TimeRange, FetchDataOptions, FetchResultTyped, TableColumn as TableColumn$1, ListViewMessages, HasUnsavedChanges, TimeRangePickerLabels, TimeRangeSelection as TimeRangeSelection$1 } from '@meshmakers/shared-ui';
+import { EntitySelectDialogDataSource, ColumnDefinition, DialogFetchOptions, DialogFetchResult, EntitySelectInputComponent, TimeRange, FetchDataOptions, FetchResultTyped, TableColumn as TableColumn$1, ListViewMessages, EntitySelectInputMessages, HasUnsavedChanges, TimeRangePickerLabels, TimeRangeSelection as TimeRangeSelection$1 } from '@meshmakers/shared-ui';
 import { EntitySelectDataSource, EntitySelectResult } from '@meshmakers/shared-services';
 import * as Apollo from 'apollo-angular';
 import { CkTypeSelectorInputComponent, AttributeValueTypeDto, FieldFilterItem, FilterVariable, PropertyGridItem, PropertyGridConfig, OctoGraphQlDataSource, FieldFilterEditorComponent } from '@meshmakers/octo-ui';
@@ -281,7 +281,7 @@ interface PersistentQueryDataSource extends WidgetDataSource {
     /**
      * Asset-scope binding: the `id` of an entity selector whose selection scopes
      * this widget's stream-data query. The selector resolves its picked entity to
-     * a set of source rtIds (via its `childScope` one-hop, or the picked entity
+     * a set of source rtIds (via its `childScope` hop or path, or the picked entity
      * itself when no childScope is configured); those rtIds are passed as the
      * query's `streamDataArgs.rtIds`, replacing the persisted RtIds at execution
      * time. Absent ⇒ the query runs with its persisted scope. Ignored for runtime
@@ -577,9 +577,29 @@ interface TableColumnStatusIconMapping {
     tooltip: string;
     color?: string;
 }
+/**
+ * Display label of one raw cell value of a table column (AB#7655), e.g. `{ label: 'L2' }` for `2`.
+ */
+interface TableColumnValueLabel {
+    /**
+     * Text shown instead of the raw value: one string for every language, or a text per culture
+     * code (`{ "de-AT": "gut", "en-GB": "good" }`) that follows the host language
+     * (`MESHBOARD_LANGUAGE`; exact culture, then language part). Without a match the raw value shows.
+     */
+    label: string | Record<string, string>;
+    /** Optional CSS text colour (e.g. `var(--kendo-color-success)`); without it the theme text colour applies. */
+    color?: string;
+}
 interface TableColumn {
     field: string;
+    /** Header text; the fallback when `titles` has no text for the host language. */
     title: string;
+    /**
+     * Header text per culture code (AB#7655), e.g. `{ "de-AT": "Datenqualität", "en-GB": "Data quality" }`.
+     * Picked for the host language (`MESHBOARD_LANGUAGE` / `provideMeshBoard({ language })`): exact
+     * culture, then a key equal to the language part (`de`), then `title`. No host language = `title`.
+     */
+    titles?: Record<string, string>;
     width?: number;
     dataType?: string;
     /**
@@ -589,6 +609,15 @@ interface TableColumn {
      */
     format?: string;
     statusMapping?: Record<string, TableColumnStatusIconMapping>;
+    /**
+     * Labels for raw cell values (AB#7655), keyed by the value as string (`"1"`, `"2"`, `"3"`); a
+     * number `2` and a string `"2"` both match `"2"`. The cell shows the label as plain text (with the
+     * optional colour); a value without a label keeps the column's `dataType` / `format` rendering,
+     * `null` / missing is an empty cell. When no label applies for the current language the column
+     * renders as without `valueLabels`. Wins over `MESHBOARD_LABEL_RESOLVER`. Not supported together
+     * with `statusMapping` (the labels are shown, a console warning is logged).
+     */
+    valueLabels?: Record<string, TableColumnValueLabel>;
 }
 /**
  * Gauge types available
@@ -639,6 +668,17 @@ interface GaugeWidgetConfig extends WidgetConfig {
     queryCategoryValue?: string;
     /** Field filters for data source */
     filters?: WidgetFilterConfig[];
+    /**
+     * How the value is obtained, as on the KPI (AB#7950). `'formula'` computes it from
+     * {@link formula} over MeshBoard variables (the data source stays `{ type: 'static' }`);
+     * `'value'` or absent uses the data source.
+     */
+    valueMode?: KpiValueMode;
+    /**
+     * Formula over MeshBoard variables, e.g. `max(0, min(100, (1 - ${import} / ${consumption}) * 100))`.
+     * Used when `valueMode` is `'formula'`; the result must be a number.
+     */
+    formula?: string;
 }
 /**
  * Pie Chart types available
@@ -832,9 +872,21 @@ type HeatmapColorScheme = 'green' | 'redGreen' | 'blue' | 'heat';
  */
 type HeatmapColorMode = 'gradient' | 'threshold';
 /**
- * Client-side aggregation function for simple queries
+ * Client-side aggregation function for simple queries.
+ * `weightedAvg` (AB#7956): cell = Σ valueField / Σ weightField, for rollup archives that store a
+ * mean as a sum column plus a count column; a cell without rows is empty, not 0.
+ */
+type HeatmapAggregation = 'count' | 'sum' | 'avg' | 'weightedAvg';
+/**
+ * Widget-level relative time window of a heatmap (AB#7956), e.g. the last 30 days.
+ * Overrides the board time filter for this widget's stream-data query.
  */
-type HeatmapAggregation = 'count' | 'sum' | 'avg';
+interface HeatmapTimeWindow {
+    /** Number of units, a positive integer */
+    value: number;
+    /** Unit of the window */
+    unit: RelativeTimeUnit;
+}
 /**
  * Heatmap Widget - displays data availability or density as a heatmap
  * X-axis: Date (day), Y-axis: Time slot (hour or 15-min interval), Color: aggregated value
@@ -851,10 +903,25 @@ interface HeatmapWidgetConfig extends WidgetConfig {
     /** Optional end-of-interval field (e.g. timeRange.to). When set, the interval width is auto-detected
      *  and sub-hour columns are shown (e.g. 00-15, 15-30, 30-45, 45-60 for 15-min data). */
     dateEndField?: string;
-    /** Field containing the numeric value to aggregate (for sum/avg) */
+    /** Field containing the numeric value to aggregate (for sum/avg; the sum column for weightedAvg) */
     valueField?: string;
     /** Client-side aggregation function for simple queries */
     aggregation: HeatmapAggregation;
+    /** `weightedAvg` only: the weight (count) column; cell = Σ valueField / Σ weightField (AB#7956) */
+    weightField?: string;
+    /**
+     * The date field marks the END of a bucket (rollup archives) (AB#7956). Each row is shifted back by
+     * {@link bucketWidthMinutes} to its bucket start before hour/day bucketing, so the last bucket of an
+     * hour stays in that hour. Ignored when {@link dateEndField} is set.
+     */
+    timestampIsBucketEnd?: boolean;
+    /** Bucket width in minutes for {@link timestampIsBucketEnd} (e.g. 5 for a 5-min rollup) */
+    bucketWidthMinutes?: number;
+    /**
+     * Own relative time window (AB#7956). When set, it overrides the board time filter for this
+     * widget's stream-data query, and the widget shows the window in a badge. Unset = board filter.
+     */
+    timeWindow?: HeatmapTimeWindow;
     /** Color scheme for the heatmap (used in `gradient` color mode) */
     colorScheme: HeatmapColorScheme;
     /** Coloring mode — relative `gradient` (default) or absolute `threshold` bands */
@@ -1374,21 +1441,44 @@ interface EntitySelectorAttributeMapping {
     attributeValueType?: string;
 }
 /**
- * One-hop association traversal that turns a selected entity into the set of
- * source rtIds a stream-data widget should be scoped to.
+ * One association hop of a multi-hop child scope (AB#7723): from the entities
+ * reached so far (the picked entity for the first hop) over `roleId` in
+ * `direction` to the entities of `targetCkTypeId`.
+ */
+interface EntitySelectorScopeHop {
+    /** Association role of this hop (e.g. "System/ParentChild"). */
+    roleId: string;
+    /** Traversal direction; defaults to `'in'` (see {@link EntitySelectorChildScope.direction}). */
+    direction?: 'in' | 'out';
+    /** CK type of the entities this hop reaches; the source type of the next hop. */
+    targetCkTypeId: string;
+}
+/**
+ * Association traversal that turns a selected entity into the set of source
+ * rtIds a stream-data widget should be scoped to.
  *
  * Use case: the user picks a `MeteringPoint`, but the stream-data archive is
  * keyed by its child `EnergyMeasurement` rtIds. The childScope describes that
- * single hop (target type + association role + direction); the selected
- * entity's children of `targetCkTypeId` reached via `roleId` become the scope
- * rtIds. When a selector has no childScope, the picked entity's own rtId is the
- * scope (direct keying).
+ * hop (target type + association role + direction); the selected entity's
+ * children of `targetCkTypeId` reached via `roleId` become the scope rtIds.
+ * When a selector has no childScope, the picked entity's own rtId is the scope
+ * (direct keying).
+ *
+ * Two forms (AB#7723):
+ * - **One hop** — the top-level `targetCkTypeId` / `roleId` / `direction`. This
+ *   is the original form; the editor keeps writing one-hop scopes this way, so
+ *   older library versions keep reading them.
+ * - **Path** — `path`, an ordered list of 2 to {@link MAX_SCOPE_HOPS} hops
+ *   (A → B → C). The source type of hop n is the target type of hop n-1; the
+ *   scope is the distinct rtIds reached by the last hop. When `path` is present
+ *   (non-empty) it wins and the top-level fields are ignored; the editor then
+ *   omits them.
  */
 interface EntitySelectorChildScope {
-    /** CK type of the child entities that key the stream-data archive (e.g. EnergyMeasurement). */
-    targetCkTypeId: string;
-    /** Association role linking the selected entity to the children (e.g. "System/ParentChild"). */
-    roleId: string;
+    /** CK type of the child entities that key the stream-data archive (e.g. EnergyMeasurement). One-hop form. */
+    targetCkTypeId?: string;
+    /** Association role linking the selected entity to the children (e.g. "System/ParentChild"). One-hop form. */
+    roleId?: string;
     /**
      * Traversal direction from the selected (parent) entity to its children.
      * For `System/ParentChild` the child owns the association to its parent, so
@@ -1396,6 +1486,35 @@ interface EntitySelectorChildScope {
      * `'out'` only for custom roles modelled parent → child.
      */
     direction?: 'in' | 'out';
+    /**
+     * Ordered multi-hop path (AB#7723). Wins over the top-level fields when
+     * non-empty. At most {@link MAX_SCOPE_HOPS} hops; a longer path, or a hop
+     * without role or target type, makes the scope fail (no data plus notice).
+     */
+    path?: EntitySelectorScopeHop[];
+}
+/** Maximum number of hops of a child-scope path, enforced by editor and runtime (AB#7723). */
+declare const MAX_SCOPE_HOPS = 5;
+/**
+ * Scope source of a dependent selector (AB#7915): the selector's picker lists
+ * only the entities reached from the leader's current pick through `path`.
+ *
+ * - `selectorId` — the leader: another selector of the same board that is
+ *   neither a follower (`followsSelectorId`) nor itself dependent. One level
+ *   only, like AB#7722 followers.
+ * - `path` — 1 to {@link MAX_SCOPE_HOPS} hops (the AB#7723 hop shape) from the
+ *   leader's CK type to this selector's CK type. Always a path, also for a
+ *   single hop (no one-hop shorthand).
+ *
+ * The picker sends the distinct rtIds at the end of the path as GraphQL field
+ * filter `rtId IN (…)`, AND-combined with the picker filter (AB#7724) and the
+ * text search. See `utils/entity-selector-scope-source.ts`.
+ */
+interface EntitySelectorScopeSource {
+    /** Id of the leader selector. */
+    selectorId: string;
+    /** Hops from the leader's CK type to this selector's CK type (1–{@link MAX_SCOPE_HOPS}). */
+    path: EntitySelectorScopeHop[];
 }
 /**
  * Configuration for a single entity selector in the MeshBoard toolbar.
@@ -1415,8 +1534,8 @@ interface EntitySelectorConfig {
     /** Optional pre-selected entity rtId */
     defaultRtId?: string;
     /**
-     * Optional one-hop traversal that resolves the picked entity to the child
-     * source rtIds a stream-data widget scopes by. Absent ⇒ the picked entity's
+     * Optional traversal (one hop, or a multi-hop `path` — AB#7723) that resolves
+     * the picked entity to the source rtIds a stream-data widget scopes by. Absent ⇒ the picked entity's
      * own rtId is the scope. See {@link EntitySelectorChildScope}.
      */
     childScope?: EntitySelectorChildScope;
@@ -1431,6 +1550,32 @@ interface EntitySelectorConfig {
      * See `utils/entity-selector-follow.ts`.
      */
     followsSelectorId?: string;
+    /**
+     * Optional picker filter (AB#7724): attribute filter rows on `ckTypeId`,
+     * combined with AND, the same type and variable substitution as widget
+     * filters (`MeshBoardVariableService.convertToFieldFilterDto`). The toolbar
+     * dropdown, its search dialog and the editor's default-entity picker send
+     * the rows as GraphQL `fieldFilter` (server side); the picker's text search
+     * is one more AND row. Absent or empty ⇒ the picker lists every entity of
+     * `ckTypeId`, as before.
+     *
+     * The filter affects the listing only: a `defaultRtId` or a URL pick that
+     * does not match is still applied (the editor warns about a non-matching
+     * `defaultRtId`). Followers have no picker; the editor writes no filter for
+     * them and a follower's filter is ignored at runtime.
+     * See `utils/entity-selector-filter.ts`.
+     */
+    filters?: WidgetFilterConfig[];
+    /**
+     * Optional scope source (AB#7915): makes this selector *dependent* on a
+     * leader selector. While the leader has a pick, the toolbar dropdown and its
+     * search dialog list only the entities reached from that pick through
+     * `path` (server side, `rtId IN`). Without a leader pick the picker lists as
+     * if no scope source were set. A failed or invalid scope lists nothing — it
+     * never falls back to the full list. Followers ignore it.
+     * See {@link EntitySelectorScopeSource}.
+     */
+    scopeSource?: EntitySelectorScopeSource;
     /** Current selection (transient, not persisted) */
     selectedRtId?: string;
     /** Display name of the currently selected entity */
@@ -1848,6 +1993,20 @@ interface QueryExecutionOptions {
     fieldFilter?: FieldFilterDto[] | null;
     /** Stream-data-only: time-range, interval, limit, queryMode. Ignored for runtime queries. */
     streamDataArgs?: StreamDataExecutionArgs | null;
+    /**
+     * Entity-selector scope (AB#7725): the source rtIds a widget bound to an entity
+     * selector is restricted to. Applied on the server for both families:
+     * - runtime queries (SimpleRtQuery, AggregationRtQuery, GroupingAggregationRtQuery):
+     *   adds the field filter `rtId IN (scopeRtIds)`, AND-combined with
+     *   {@link fieldFilter} and the persisted query's own filters — a grouping or
+     *   aggregation query aggregates over the scoped entities only;
+     * - stream-data queries: sent as `arg.rtIds` unless `streamDataArgs.rtIds` is set.
+     *
+     * `null`/`undefined` or an empty array means "no scope" (the query runs as saved).
+     * An empty scope must never reach the executor: callers skip the query instead
+     * (`StreamDataScope.kind === 'empty'`, AB#7721).
+     */
+    scopeRtIds?: string[] | null;
     /** Force a network round-trip instead of using the Apollo cache. */
     forceRefresh?: boolean;
 }
@@ -1989,6 +2148,16 @@ declare class QueryExecutorService {
      * {@link ENTITY_GROUP_FETCH_CAP}; a truncated read is logged (never silently capped).
      */
     fetchEntityGroups(ckTypeId: string, groupField: string, restrictRtIds?: string[]): Promise<Map<string, string[]>>;
+    /**
+     * Runtime entity-selector scope (AB#7725): appends `rtId IN (scopeRtIds)` to the
+     * caller's field filters. The backend AND-combines all runtime field filters with
+     * the persisted query's filters before the database query, so simple rows as well
+     * as aggregation / grouping results cover the scoped entities only. Returns the
+     * caller's filters unchanged (or `undefined`) when there is no scope.
+     */
+    static withRtIdScope(fieldFilter: FieldFilterDto[] | null | undefined, scopeRtIds: string[] | null | undefined): FieldFilterDto[] | undefined;
+    /** Stream-data entity-selector scope: `scopeRtIds` fill `rtIds` unless the caller set them. */
+    private static withStreamDataScope;
     private buildStreamDataArg;
     private mapColumns;
     private mapRuntimeRows;
@@ -2003,9 +2172,13 @@ declare class QueryExecutorService {
  * transiently by `MeshBoardStateService`, written by the view while a pick is
  * resolved to its source rtIds.
  *
- * - `pending`: the pick is being resolved (one-hop childScope traversal).
+ * - `pending`: the pick is being resolved (childScope traversal, one hop or a path).
  * - `resolved`: the pick resolved to `rtIds` — possibly none.
  * - `failed`: the resolution threw (e.g. the association fetch failed).
+ * - `needsPick` (AB#7916): a dependent selector (`scopeSource`) — or a follower
+ *   of one — has no pick while its leader has one. Bound widgets show no data
+ *   and the view asks for a pick; the persisted scope would show entities
+ *   outside the leader's pick. Only used for widget scopes, never for picker scopes.
  *
  * A selector without an entry has no active pick: bound widgets keep the
  * query's persisted scope.
@@ -2017,19 +2190,30 @@ type EntitySelectorScopeState = {
     rtIds: string[];
 } | {
     status: 'failed';
+} | {
+    status: 'needsPick';
 };
 /**
- * What a widget bound to an entity selector does with its stream-data query
- * (AB#7721). Returned by `MeshBoardStateService.resolveStreamDataScope`.
+ * What a widget bound to an entity selector does with its persistent query —
+ * stream data (AB#7721) and runtime queries (AB#7725). Returned by
+ * `MeshBoardStateService.resolveEntitySelectorScope`.
  *
- * - `unscoped`: no binding, a runtime query, or no active pick — query with the
- *   persisted scope (unchanged behaviour).
+ * - `unscoped`: no binding or no active pick — query with the persisted scope
+ *   (unchanged behaviour).
  * - `pending`: the scope is still resolving — show the loading state and send
  *   NO query; the view triggers a refresh once the scope is known.
- * - `scoped`: query with `rtIds` as `streamDataArgs.rtIds`.
+ * - `scoped`: query restricted to `rtIds` on the server — stream data via
+ *   `streamDataArgs.rtIds`, runtime queries (simple, aggregation, grouping) via
+ *   the field filter `rtId IN (rtIds)` (`QueryExecutionOptions.scopeRtIds`).
  * - `empty`: the pick has nothing in scope (`noTargets`) or the lookup failed
  *   (`failed`) — show the no-data state and send NO query. Never fall back to
  *   the persisted scope: that would show rows of other entities.
+ *   `noPick` (AB#7916): a dependent selector has no pick while its leader has
+ *   one — the view shows "Pick a <label> to see this data.".
+ *   `invalidTimeRange` (AB#7582): the embedding host set a `timeRange` that is
+ *   unparseable or empty (`from >= to`) — every stream-data query bound to the
+ *   time filter is skipped, whatever its selector binding; a widget with
+ *   `ignoreTimeFilter` is not affected.
  */
 type StreamDataScope = {
     kind: 'unscoped';
@@ -2040,7 +2224,7 @@ type StreamDataScope = {
     rtIds: string[];
 } | {
     kind: 'empty';
-    reason: 'noTargets' | 'failed';
+    reason: 'noTargets' | 'failed' | 'noPick' | 'invalidTimeRange';
 };
 /**
  * The result a widget renders instead of executing its query when its scope is
@@ -2282,6 +2466,83 @@ declare class WidgetNotConfiguredComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WidgetNotConfiguredComponent, "mm-widget-not-configured", never, {}, {}, never, never, true, never>;
 }
 
+interface FormulaValidationResult {
+    valid: boolean;
+    /** Syntax error or other reason the formula is invalid */
+    error?: string;
+    /** Referenced variables that do not exist (bare identifiers are reported as well) */
+    unknownVariables: string[];
+}
+/**
+ * Outcome of evaluating a formula:
+ * - `ok`: a value;
+ * - `pending`: empty formula or a referenced variable has no value yet → the widget shows `-`, no error;
+ * - `nonFinite`: the result is `Infinity`/`NaN` (e.g. division by zero, PV = 0 at night) → the widget
+ *   shows `-` and the `reason` as tooltip, no error state (AB#7950);
+ * - `error`: syntax or evaluation error → the widget error state with the message.
+ */
+type FormulaEvaluationResult = {
+    status: 'pending';
+} | {
+    status: 'ok';
+    value: number | string | boolean;
+} | {
+    status: 'nonFinite';
+    reason: string;
+} | {
+    status: 'error';
+    error: string;
+};
+
+/**
+ * Formula field shared by the widget config dialogs (KPI, gauge; AB#7950): the formula input,
+ * the syntax hint, the validation message, the live preview and the list of insertable variables.
+ *
+ * Validation is `validateFormulaField` of `utils/meshboard-formula.ts` — the dialogs call the same
+ * function to decide whether Save is enabled, so there is exactly one validation rule.
+ *
+ * Usage:
+ * ```html
+ * <mm-meshboard-formula-field
+ *   [(formula)]="form.formula"
+ *   [variables]="formulaVariables"
+ *   [declaredNames]="declaredVariableNames">
+ * </mm-meshboard-formula-field>
+ * ```
+ */
+declare class FormulaFieldComponent {
+    private readonly evaluator;
+    /** The formula text (two-way: `[(formula)]`) */
+    readonly formula: _angular_core.ModelSignal<string>;
+    /** Variables the formula can reference; their current values drive the preview */
+    readonly variables: _angular_core.InputSignal<readonly MeshBoardVariable[]>;
+    /** Names that exist by configuration but carry no value yet (count as known, preview pending) */
+    readonly declaredNames: _angular_core.InputSignal<readonly string[]>;
+    /** The result must be a number (gauge): a string/boolean preview shows "Result is not a number" */
+    readonly numericOnly: _angular_core.InputSignal<boolean>;
+    /** Show the clamp pattern in the hint (widgets with a scale) */
+    readonly clampHint: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly variableSyntaxHint = "${variableName}";
+    readonly clampExample = "max(0, min(100, \u2026))";
+    private readonly id;
+    readonly inputId: string;
+    readonly hintId: string;
+    readonly messageId: string;
+    readonly variablesLabelId: string;
+    /** Validation of the current formula (the same rule the dialogs use for Save) */
+    readonly validation: _angular_core.Signal<FormulaValidationResult>;
+    /** Evaluation of the current formula over the current variable values */
+    readonly evaluation: _angular_core.Signal<FormulaEvaluationResult>;
+    readonly preview: _angular_core.Signal<string>;
+    readonly inputAttributes: _angular_core.Signal<Record<string, string>>;
+    /** Appends a `${name}` reference to the formula */
+    insertVariable(name: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormulaFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormulaFieldComponent, "mm-meshboard-formula-field", never, { "formula": { "alias": "formula"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; "declaredNames": { "alias": "declaredNames"; "required": false; "isSignal": true; }; "numericOnly": { "alias": "numericOnly"; "required": false; "isSignal": true; }; "clampHint": { "alias": "clampHint"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "formula": "formulaChange"; }, never, never, true, never>;
+}
+
 /**
  * Defines how parent associations should be handled when mapping widget input
  */
@@ -2425,6 +2686,20 @@ declare class MeshBoardPersistenceService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardPersistenceService>;
 }
 
+/**
+ * The period an embedding host sets on the board (AB#7582): two exact instants
+ * (half-open `[from, to)`), or `invalid` (with the reason) when the host passed an
+ * unparseable or empty range. Produced by `parseHostTimeRange`, held transiently by
+ * {@link MeshBoardStateService.setHostTimeRange}.
+ */
+type HostTimeRangeState = {
+    status: 'valid';
+    from: Date;
+    to: Date;
+} | {
+    status: 'invalid';
+    reason: string;
+};
 /**
  * Service that manages MeshBoard state and persistence.
  * Coordinates loading, saving, and switching between MeshBoards.
@@ -2445,12 +2720,28 @@ declare class MeshBoardStateService {
     /**
      * Transient scope state of each entity selector's current selection (keyed
      * by selector id): `pending` while the view resolves the pick, `resolved`
-     * with the source rtIds (one-hop childScope traversal, or the picked entity's
+     * with the source rtIds (childScope hop or path, or the picked entity's
      * own rtId; possibly none), or `failed`. No entry = no active pick. Not
      * persisted — derived fresh from each selection, cleared on board switch
      * (AB#7721).
      */
     private readonly _entitySelectorScopes;
+    /**
+     * Transient picker scope of each dependent selector (AB#7915, keyed by the
+     * dependent's id): `pending` while the leader's pick resolves along
+     * `scopeSource.path`, `resolved` with the rtIds the picker may list
+     * (possibly none), or `failed`. No entry = the leader has no pick, the picker
+     * lists unscoped. Not persisted, cleared on board switch.
+     */
+    private readonly _pickerScopes;
+    /** Picker scopes of the dependent selectors (AB#7915), for the toolbar. */
+    readonly pickerScopes: _angular_core.Signal<Record<string, EntitySelectorScopeState>>;
+    /**
+     * Period set by the page that embeds the board (`MeshBoardViewComponent.timeRange`, AB#7582):
+     * exact instants, or `invalid` when the host passed an unusable range. `null` = the board's own
+     * selection applies. Transient — never persisted, never written into the board config.
+     */
+    private readonly _hostTimeRange;
     /**
      * Transient variables published by widgets (KPI output variables, AB#5364).
      * Kept apart from `_meshBoardConfig` so publishing triggers no persistence and
@@ -2702,6 +2993,11 @@ declare class MeshBoardStateService {
      * Boundaries are resolved on the board's {@link timeZoneMode} basis (local by
      * default, or UTC), the same basis widgets format their datetime display on —
      * so the selected range and the displayed timestamps stay consistent.
+     *
+     * While an embedding host has set a period ({@link setHostTimeRange}, AB#7582)
+     * and the board's time filter is enabled, the host's instants are returned
+     * unchanged (no day snapping, no zone conversion) and the stored selection is
+     * ignored; an invalid host period resolves to `null`.
      */
     resolveCurrentTimeRange(): TimeRange | null;
     /**
@@ -2742,7 +3038,7 @@ declare class MeshBoardStateService {
     /**
      * Stores the source rtIds resolved from an entity selector's current
      * selection. Called by the view component after a selection resolves (the
-     * one-hop childScope traversal, or the picked entity's own rtId when the
+     * childScope traversal (one hop or a path), or the picked entity's own rtId when the
      * selector has no childScope). An empty array is a resolved EMPTY scope:
      * bound widgets show no data and send no query (AB#7721). Transient — not
      * persisted.
@@ -2755,6 +3051,13 @@ declare class MeshBoardStateService {
      * (AB#7721).
      */
     setEntitySelectorScopeFailed(selectorId: string): void;
+    /**
+     * Marks a selector as "needs a pick" (AB#7916): a dependent selector — or a
+     * follower of one — has no pick while its leader has one. Bound widgets show
+     * no data and send no query (never the persisted scope, which would show
+     * entities outside the leader's pick); the view asks for a pick.
+     */
+    setEntitySelectorScopeNeedsPick(selectorId: string): void;
     /**
      * Clears the scope state for an entity selector (its selection was cleared).
      * Bound widgets then query with the persisted scope again.
@@ -2768,19 +3071,39 @@ declare class MeshBoardStateService {
      */
     readonly failedEntitySelectorScopeIds: _angular_core.Signal<string[]>;
     /**
-     * Decides how a widget bound to an entity selector runs its stream-data query
-     * (AB#7721):
+     * Ids of the selectors that need a pick (AB#7916), for the view's
+     * "Pick a <label> to see this data." notice.
+     */
+    readonly needsPickEntitySelectorIds: _angular_core.Signal<string[]>;
+    /**
+     * Decides how a widget runs its persistent query — the entry point every
+     * built-in widget calls with its binding, query family and time-filter opt-out:
      *
-     * - `unscoped` — no binding, a runtime query (`family === 'runtime'`, the
-     *   binding is ignored there), or no active pick: keep the persisted scope.
+     * 1. Host gate (AB#7582): while the embedding host's period is invalid, every
+     *    stream-data query bound to the time filter is `empty` (`invalidTimeRange`),
+     *    whatever its selector binding; pass the widget's `ignoreTimeFilter` so an
+     *    opted-out widget, whose data does not depend on the period, keeps querying.
+     *    Runtime queries have no time window and are not gated. A legacy config
+     *    without `queryFamily` is treated as stream data here.
+     * 2. Entity-selector scope ({@link resolveEntitySelectorScope}, AB#7721) — since
+     *    AB#7725 for runtime queries too: `unscoped` / `pending` / `scoped` / `empty`.
+     */
+    resolveStreamDataScope(entitySelectorId?: string, family?: QueryFamily, ignoreTimeFilter?: boolean): StreamDataScope;
+    /**
+     * The entity-selector part of {@link resolveStreamDataScope}, without the host
+     * gate — stream data (AB#7721) and runtime queries alike (AB#7725):
+     *
+     * - `unscoped` — no binding, or no active pick: keep the query as saved.
      * - `pending` — the pick is still resolving: show loading, send no query.
-     * - `scoped` — query with the resolved source rtIds.
+     * - `scoped` — query restricted to the resolved rtIds: stream data via
+     *   `streamDataArgs.rtIds`, runtime queries via the `rtId IN` field filter
+     *   (`QueryExecutionOptions.scopeRtIds`).
      * - `empty` — the pick has nothing in scope or the lookup failed: show the
      *   no-data state and send no query. Never fall back to the persisted scope.
-     *
-     * A legacy config without `queryFamily` is treated as stream data.
+     *   Also a dependent selector without pick while its leader has one
+     *   (`noPick`, AB#7916).
      */
-    resolveStreamDataScope(entitySelectorId?: string, family?: QueryFamily): StreamDataScope;
+    resolveEntitySelectorScope(entitySelectorId?: string): StreamDataScope;
     /**
      * Resolves the stream-data `rtIds` for a persistent-query widget bound to an
      * entity selector: the resolved source rtIds when the scope is `scoped`,
@@ -2791,7 +3114,43 @@ declare class MeshBoardStateService {
      * skip the query for `pending` / `empty` (AB#7721).
      */
     resolveStreamDataRtIds(entitySelectorId?: string): string[] | undefined;
+    /** Marks a dependent selector's picker scope as resolving (AB#7915): the picker lists nothing yet. */
+    setPickerScopePending(selectorId: string): void;
+    /** Stores the rtIds a dependent selector's picker may list (AB#7915); `[]` = nothing in the leader's pick. */
+    setPickerScopeRtIds(selectorId: string, rtIds: string[]): void;
+    /** Marks a dependent selector's picker scope as failed (AB#7915): the picker lists nothing. */
+    setPickerScopeFailed(selectorId: string): void;
+    /** Clears a dependent selector's picker scope (its leader has no pick): the picker lists unscoped. */
+    clearPickerScope(selectorId: string): void;
+    /** The picker scope of a dependent selector, or `undefined` when its leader has no pick. */
+    getPickerScopeState(selectorId: string): EntitySelectorScopeState | undefined;
+    private setPickerScope;
     private setEntitySelectorScope;
+    /**
+     * Sets (or with `null` clears) the period of the page embedding the board
+     * (AB#7582). Called by `MeshBoardViewComponent` for its `timeRange` input; a
+     * host normally sets the input instead of calling this. Transient: not
+     * persisted, not written into the board config, so it never causes unsaved
+     * changes. Only takes effect while the board's time filter is enabled.
+     */
+    setHostTimeRange(state: HostTimeRangeState | null, owner?: object): void;
+    /**
+     * Clears the host period only if `owner` set it (AB#7582). The service is
+     * root-provided, so a view that is destroyed (or drops its `timeRange`) must not
+     * clear a period another view set in the meantime.
+     */
+    clearHostTimeRange(owner: object): void;
+    /** The view (or other caller) that set the current host period, if it said so. */
+    private hostTimeRangeOwner;
+    /** The period set by the embedding host, or `null` when the board's own selection applies. */
+    readonly hostTimeRange: _angular_core.Signal<HostTimeRangeState | null>;
+    /**
+     * True when an invalid host period blocks a stream-data query that is bound to
+     * the time filter (AB#7582): the period is invalid, the board's time filter is
+     * enabled and the caller did not opt out with `ignoreTimeFilter`. Such a query
+     * must not be sent — without a window it would read the whole archive.
+     */
+    isStreamDataBlockedByHostTimeRange(ignoreTimeFilter?: boolean): boolean;
     /**
      * Updates the time filter configuration.
      */
@@ -2893,12 +3252,17 @@ interface RepeaterDataItem {
     /** All attributes as a Map for easy access */
     attributes: Map<string, unknown>;
 }
+/** Source rtIds per request of one batched association hop (AB#7723). */
+declare const ASSOCIATION_HOP_SOURCE_BATCH = 100;
+/** Targets read per source entity in one association hop (AB#7723). */
+declare const ASSOCIATION_HOP_TARGETS_PER_SOURCE = 1000;
 declare class MeshBoardDataService {
     private readonly getDashboardEntityGQL;
     private readonly getCkModelsWithStateGQL;
     private readonly getEntitiesByCkTypeGQL;
     private readonly queryExecutor;
     private readonly getAssociationTargetsGQL;
+    private readonly getAssociationTargetRtIdsGQL;
     private readonly secretSafeNames;
     private readonly getCkTypeAttributesGQL;
     private readonly apollo;
@@ -2981,6 +3345,20 @@ declare class MeshBoardDataService {
      * Uses the associations.targets() GraphQL endpoint.
      */
     fetchAssociationTargets(sourceRtId: string, sourceCkTypeId: string, targetCkTypeId: string, roleId: string, direction: 'in' | 'out', attributeNames?: string[], first?: number): Observable<TargetEntityWithAttributes[]>;
+    /**
+     * One association hop for MANY source entities (AB#7723, multi-hop child
+     * scope): the rtIds of the `targetCkTypeId` entities reached from each of
+     * `sourceRtIds` (all of `sourceCkTypeId`) over `roleId` in `direction`.
+     *
+     * Query cost: the sources go out in batches of
+     * {@link ASSOCIATION_HOP_SOURCE_BATCH} rtIds per request (`runtimeEntities(rtIds:)`
+     * with the association targets nested), the batches of one hop in parallel —
+     * never one request per entity. Only rtIds are selected. Per source at most
+     * {@link ASSOCIATION_HOP_TARGETS_PER_SOURCE} targets are read; a truncated
+     * source is logged as a warning. Duplicates are not removed here.
+     * Errors propagate (the caller turns them into a failed scope).
+     */
+    fetchAssociationTargetRtIds(sourceRtIds: readonly string[], sourceCkTypeId: string, targetCkTypeId: string, roleId: string, direction: 'in' | 'out'): Observable<string[]>;
     /**
      * Fetches CK type attribute definitions (name + type) for config dialog.
      */
@@ -3599,6 +3977,11 @@ declare class KpiWidgetComponent implements DashboardWidget<KpiWidgetConfig, Run
     private readonly formulaResult;
     /** Error message of the formula (syntax, evaluation or circular reference). */
     readonly formulaError: _angular_core.Signal<string | null>;
+    /**
+     * Tooltip of the value: the reason a formula result is shown as `-` although every
+     * variable has a value (non-finite result, e.g. division by zero; AB#7950), else `null`.
+     */
+    readonly valueTooltip: _angular_core.Signal<string | null>;
     /**
      * Unformatted value: the formula result, or the value taken from the loaded data
      * (query values already scaled by `valueMultiplier`).
@@ -3652,14 +4035,6 @@ declare class KpiWidgetComponent implements DashboardWidget<KpiWidgetConfig, Run
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KpiWidgetComponent, "mm-kpi-widget", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-interface FormulaValidationResult {
-    valid: boolean;
-    /** Syntax error or other reason the formula is invalid */
-    error?: string;
-    /** Referenced variables that do not exist (bare identifiers are reported as well) */
-    unknownVariables: string[];
-}
-
 /**
  * Data source type for KPI. `'formula'` computes the value from a formula over
  * MeshBoard variables (stored as static data source with `valueMode: 'formula'`).
@@ -3799,15 +4174,13 @@ declare class KpiConfigDialogComponent implements OnInit {
      * outputs declared by other KPIs (e.g. still loading or in error) and the variables an
      * entity selector exposes once an entity is picked.
      */
-    private get declaredVariableNames();
+    get declaredVariableNames(): string[];
     /**
      * Validation of the current formula (memoized per formula text and available variable names).
      * Declared names count as known, so a reference to an output without a value yet can be saved;
      * the preview keeps evaluating the live values and shows it as pending.
      */
     get formulaValidation(): FormulaValidationResult;
-    /** Result of the current formula over the current variable values */
-    get formulaPreview(): string;
     /** Validation message for the output variable name, or `null` when valid or empty */
     get outputVariableError(): string | null;
     /** Circular reference introduced by the pending formula / output name, or `null` */
@@ -3835,8 +4208,6 @@ declare class KpiConfigDialogComponent implements OnInit {
     private displayFields;
     onCancel(): void;
     onDataSourceTypeChange(type: KpiDataSourceType): void;
-    /** Appends a `${name}` reference to the formula */
-    insertVariable(name: string): void;
     onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
     onQueryModeChange(mode: KpiQueryMode): Promise<void>;
     private loadQueryColumnsAndValues;
@@ -4131,17 +4502,34 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
     dataSource?: TableWidgetDataSourceDirective;
     private readonly stateService;
     /** Host texts (`MESHBOARD_MESSAGES`, AB#5622): list texts (empty state, pager, toolbar) and the placeholder. */
-    protected readonly texts: _angular_core.Signal<_meshmakers_octo_meshboard.MeshBoardMessages & Required<Omit<_meshmakers_octo_meshboard.MeshBoardMessages, "tableList">>>;
+    protected readonly texts: Signal<_meshmakers_octo_meshboard.MeshBoardMessages & Required<Omit<_meshmakers_octo_meshboard.MeshBoardMessages, "tableList">>>;
     /** Host translation of enum cell values (`MESHBOARD_LABEL_RESOLVER`, AB#5622); absent = raw text. */
     private readonly labelResolver;
     /** CK value type per derived column field (persistent queries), for the label resolver. */
     private readonly _queryColumnValueTypes;
+    /** Host UI language (`MESHBOARD_LANGUAGE`, AB#7655) for column `titles` / `valueLabels`; `null` = `title` / raw texts. */
+    private readonly language;
+    /**
+     * Problems already warned about (`<widget id or instance>|<field>|<problem hash>`), so a bad config
+     * logs once, not on every language change, while a new problem after a config edit is reported again.
+     */
+    private readonly warnedColumns;
+    /** Fallback warning key of a widget without an id. */
+    private readonly instanceKey;
+    /** App locale for the `number` / `date` rendering of unlabelled values in value-label columns. */
+    private readonly locale;
+    /**
+     * Bumped on every `config` change: `config` is a plain `@Input`, so the computeds that read it
+     * depend on this signal to pick up a new config on the same widget instance (AB#7655).
+     */
+    private readonly _configVersion;
+    constructor();
     private readonly _isLoading;
     private readonly _data;
     private readonly _error;
-    readonly isLoading: _angular_core.Signal<boolean>;
-    readonly data: _angular_core.Signal<Record<string, unknown>[]>;
-    readonly error: _angular_core.Signal<string | null>;
+    readonly isLoading: Signal<boolean>;
+    readonly data: Signal<Record<string, unknown>[]>;
+    readonly error: Signal<string | null>;
     /** Signal to track query columns from data source (for persistent queries) */
     private readonly _queryColumnsForView;
     /**
@@ -4153,7 +4541,7 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
      * Converts TableWidgetConfig columns to ListViewComponent TableColumn format.
      * For persistent queries, uses dynamically derived columns from the query response.
      */
-    readonly listViewColumns: _angular_core.Signal<TableColumn$1[]>;
+    readonly listViewColumns: Signal<TableColumn$1[]>;
     /**
      * Checks if the widget has a valid configuration.
      * Supports both runtimeEntity and persistentQuery data sources.
@@ -4164,7 +4552,15 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
      * For persistent queries, columns are derived from the query response.
      * Returns true once columns are available.
      */
-    readonly columnsReady: _angular_core.Signal<boolean>;
+    readonly columnsReady: Signal<boolean>;
+    /**
+     * Logs one console warning per widget, column and set of problems for ignored `titles` /
+     * `valueLabels` entries (unknown culture keys, malformed titles or value labels, `valueLabels`
+     * together with `statusMapping`, AB#7655). The table still renders. The key carries a hash of the
+     * problem list, so a different problem after a config edit is reported again; widgets without an
+     * id use a per-instance key.
+     */
+    private warnOnce;
     private formatColumnTitle;
     ngOnChanges(changes: SimpleChanges): void;
     refresh(): void;
@@ -4208,6 +4604,10 @@ declare class TableConfigDialogComponent implements OnInit {
     private readonly getCkTypeAvailableQueryColumnsGQL;
     private readonly stateService;
     private readonly windowRef;
+    private readonly getRuntimeQueryColumnsGQL;
+    private readonly queryExecutor;
+    /** Fields the saved query returns now, loaded once per query rtId (AB#7655, kept explicit columns). */
+    private queryFieldsLoad?;
     ckTypeSelectorInput?: CkTypeSelectorInputComponent;
     filterEditor?: FieldFilterEditorComponent;
     querySelector?: QuerySelectorComponent;
@@ -4265,7 +4665,13 @@ declare class TableConfigDialogComponent implements OnInit {
     onFiltersChange(filters: FieldFilterItem[]): void;
     getColumnsSummary(): string;
     getSortingSummary(): string;
-    onSave(): void;
+    /**
+     * The fields a persistent query returns now (`null` when unknown or the lookup failed). Runtime
+     * queries use the metadata-only column resolver; stream-data queries execute with `first: 1`
+     * (no column-introspection endpoint), like the chart dialogs.
+     */
+    private loadQueryFields;
+    onSave(): Promise<void>;
     private formatColumnTitle;
     onCancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableConfigDialogComponent, never>;
@@ -4282,10 +4688,23 @@ declare class GaugeWidgetComponent implements DashboardWidget<GaugeWidgetConfig,
     private static readonly SUPPORTED_ROW_TYPES;
     private readonly stateService;
     private readonly variableService;
+    private readonly expressionEvaluator;
     config: GaugeWidgetConfig;
+    /**
+     * Signal mirror of the `config` input, so the formula computeds re-run when the config
+     * changes (the input itself is a plain property). Falls back to the input before the
+     * first lifecycle hook.
+     */
+    private readonly _config;
+    private currentConfig;
     private readonly _isLoading;
     private readonly _data;
     private readonly _error;
+    /**
+     * Incremented on every load; a request that resolves after a newer load started (e.g. the
+     * config switched to formula mode meanwhile) must not overwrite the newer state.
+     */
+    private loadGeneration;
     readonly isLoading: _angular_core.Signal<boolean>;
     readonly data: _angular_core.Signal<RuntimeEntityData | null>;
     readonly error: _angular_core.Signal<string | null>;
@@ -4294,7 +4713,31 @@ declare class GaugeWidgetComponent implements DashboardWidget<GaugeWidgetConfig,
      * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
      */
     isNotConfigured(): boolean;
+    /** True when the value is computed from a formula over MeshBoard variables (AB#7950). */
+    isFormulaMode(): boolean;
+    /**
+     * Formula evaluation result, live over the MeshBoard variables (AB#7950); `null` outside
+     * formula mode. Same engine and rules as the KPI, but the result must be a number.
+     * A gauge publishes no output variable, so it can never be part of a variable cycle.
+     */
+    private readonly formulaResult;
+    /** Error message of the formula (syntax, evaluation, non-numeric result). */
+    readonly formulaError: _angular_core.Signal<string | null>;
+    /**
+     * Tooltip of the value label: the reason a formula result is shown as `-` although every
+     * variable has a value (non-finite result, e.g. division by zero), else `null`.
+     */
+    readonly valueTooltip: _angular_core.Signal<string | null>;
+    /** True when there is a value to show (data loaded, or a formula result). */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /** The real value, shown in the label (may lie outside the scale). */
     readonly numericValue: _angular_core.Signal<number>;
+    /**
+     * Value of the pointer: the real value clamped to the scale, so the pointer stops at the
+     * scale end while the label shows the real value (AB#7950). Without a value it rests at
+     * the scale start.
+     */
+    readonly pointerValue: _angular_core.Signal<number>;
     readonly formattedValue: _angular_core.Signal<string>;
     readonly label: _angular_core.Signal<string>;
     ngOnInit(): void;
@@ -4316,9 +4759,10 @@ declare class GaugeWidgetComponent implements DashboardWidget<GaugeWidgetConfig,
 }
 
 /**
- * Data source type for Gauge
+ * Data source type for Gauge. `'formula'` computes the value from a formula over MeshBoard
+ * variables (stored as static data source with `valueMode: 'formula'`, AB#7950).
  */
-type GaugeDataSourceType = 'runtimeEntity' | 'persistentQuery';
+type GaugeDataSourceType = 'runtimeEntity' | 'persistentQuery' | 'formula';
 /**
  * Configuration result from the Gauge dialog
  */
@@ -4338,6 +4782,7 @@ interface GaugeConfigResult extends WidgetConfigResult {
     queryValueField?: string;
     queryCategoryField?: string;
     queryCategoryValue?: string;
+    formula?: string;
     gaugeType: GaugeType;
     min?: number;
     max?: number;
@@ -4371,6 +4816,7 @@ declare class GaugeConfigDialogComponent implements OnInit {
     private static readonly INTROSPECTION_ROW_TYPES;
     private readonly meshBoardStateService;
     private readonly windowRef;
+    private readonly expressionEvaluator;
     ckTypeSelectorInput?: CkTypeSelectorInputComponent;
     entitySelectorInput?: EntitySelectInputComponent;
     querySelector?: QuerySelectorComponent;
@@ -4397,6 +4843,9 @@ declare class GaugeConfigDialogComponent implements OnInit {
     initialQueryCategoryField?: string;
     initialQueryCategoryValue?: string;
     initialFilters?: WidgetFilterConfig[];
+    /** Id of the edited widget (excluded from the declared output names) */
+    initialWidgetId?: string;
+    initialFormula?: string;
     dataSourceType: GaugeDataSourceType;
     selectedCkType: CkTypeSelectorItem | null;
     selectedEntity: RuntimeEntityItem | null;
@@ -4436,7 +4885,18 @@ declare class GaugeConfigDialogComponent implements OnInit {
         queryValueField: string;
         queryCategoryField: string;
         queryCategoryValue: string;
+        formula: string;
     };
+    /**
+     * Variables a formula can reference: MeshBoard variables plus the KPIs' published outputs.
+     * Read live, so outputs published while the dialog is open become available immediately.
+     */
+    get formulaVariables(): MeshBoardVariable[];
+    /** Names that exist by configuration but carry no value yet (declared KPI outputs, selector variables) */
+    get declaredVariableNames(): string[];
+    private formulaValidationCache?;
+    /** Validation of the current formula — the same rule the shared formula field shows */
+    get formulaValidation(): FormulaValidationResult;
     gaugeTypeOptions: GaugeTypeOption[];
     queryModeOptions: {
         value: KpiQueryMode;
@@ -4456,6 +4916,8 @@ declare class GaugeConfigDialogComponent implements OnInit {
     addRange(): void;
     removeRange(index: number): void;
     onSave(): void;
+    /** Gauge options shared by every data source */
+    private gaugeOptionsResult;
     onCancel(): void;
     onDataSourceTypeChange(type: GaugeDataSourceType): void;
     onQuerySelected(query: PersistentQueryItem | null): Promise<void>;
@@ -4472,7 +4934,7 @@ declare class GaugeConfigDialogComponent implements OnInit {
     private loadCategoryValuesForField;
     onFiltersChange(updatedFilters: FieldFilterItem[]): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaugeConfigDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaugeConfigDialogComponent, "mm-gauge-config-dialog", never, { "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialRtId": { "alias": "initialRtId"; "required": false; }; "initialGaugeType": { "alias": "initialGaugeType"; "required": false; }; "initialValueAttribute": { "alias": "initialValueAttribute"; "required": false; }; "initialLabelAttribute": { "alias": "initialLabelAttribute"; "required": false; }; "initialMin": { "alias": "initialMin"; "required": false; }; "initialMax": { "alias": "initialMax"; "required": false; }; "initialRanges": { "alias": "initialRanges"; "required": false; }; "initialShowLabel": { "alias": "initialShowLabel"; "required": false; }; "initialPrefix": { "alias": "initialPrefix"; "required": false; }; "initialSuffix": { "alias": "initialSuffix"; "required": false; }; "initialReverse": { "alias": "initialReverse"; "required": false; }; "initialDataSourceType": { "alias": "initialDataSourceType"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialQueryFamily": { "alias": "initialQueryFamily"; "required": false; }; "initialIgnoreTimeFilter": { "alias": "initialIgnoreTimeFilter"; "required": false; }; "initialEntitySelectorId": { "alias": "initialEntitySelectorId"; "required": false; }; "initialQueryMode": { "alias": "initialQueryMode"; "required": false; }; "initialQueryValueField": { "alias": "initialQueryValueField"; "required": false; }; "initialQueryCategoryField": { "alias": "initialQueryCategoryField"; "required": false; }; "initialQueryCategoryValue": { "alias": "initialQueryCategoryValue"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaugeConfigDialogComponent, "mm-gauge-config-dialog", never, { "initialCkTypeId": { "alias": "initialCkTypeId"; "required": false; }; "initialRtId": { "alias": "initialRtId"; "required": false; }; "initialGaugeType": { "alias": "initialGaugeType"; "required": false; }; "initialValueAttribute": { "alias": "initialValueAttribute"; "required": false; }; "initialLabelAttribute": { "alias": "initialLabelAttribute"; "required": false; }; "initialMin": { "alias": "initialMin"; "required": false; }; "initialMax": { "alias": "initialMax"; "required": false; }; "initialRanges": { "alias": "initialRanges"; "required": false; }; "initialShowLabel": { "alias": "initialShowLabel"; "required": false; }; "initialPrefix": { "alias": "initialPrefix"; "required": false; }; "initialSuffix": { "alias": "initialSuffix"; "required": false; }; "initialReverse": { "alias": "initialReverse"; "required": false; }; "initialDataSourceType": { "alias": "initialDataSourceType"; "required": false; }; "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialQueryFamily": { "alias": "initialQueryFamily"; "required": false; }; "initialIgnoreTimeFilter": { "alias": "initialIgnoreTimeFilter"; "required": false; }; "initialEntitySelectorId": { "alias": "initialEntitySelectorId"; "required": false; }; "initialQueryMode": { "alias": "initialQueryMode"; "required": false; }; "initialQueryValueField": { "alias": "initialQueryValueField"; "required": false; }; "initialQueryCategoryField": { "alias": "initialQueryCategoryField"; "required": false; }; "initialQueryCategoryValue": { "alias": "initialQueryCategoryValue"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; "initialWidgetId": { "alias": "initialWidgetId"; "required": false; }; "initialFormula": { "alias": "initialFormula"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -5256,8 +5718,8 @@ interface HeatmapDataItem {
     date: string;
     /** Y-axis: hour label (e.g. '08:00') */
     hour: string;
-    /** Color intensity value */
-    value: number;
+    /** Color intensity value; `null` = empty cell (`weightedAvg` without rows, AB#7956) */
+    value: number | null;
     /** Per-cell color (transparent for no-data) */
     color: string;
 }
@@ -5281,10 +5743,10 @@ declare class HeatmapWidgetComponent implements DashboardWidget<HeatmapWidgetCon
     readonly error: _angular_core.Signal<string | null>;
     readonly data: _angular_core.Signal<HeatmapDataItem[]>;
     /**
-     * Returns the color for a given value based on the color scheme ranges.
-     * Returns 'transparent' for zero/no-data values.
+     * Returns the gradient color for a filled cell based on the color scheme ranges.
+     * Empty cells are made transparent by the caller ({@link isEmptyCell}).
      */
-    private getColorForValue;
+    private rangeColor;
     isNotConfigured(): boolean;
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
@@ -5297,8 +5759,18 @@ declare class HeatmapWidgetComponent implements DashboardWidget<HeatmapWidgetCon
      */
     private formatSI;
     cellLabelContent: (e: {
-        value: number;
+        value: number | null;
     }) => string;
+    /**
+     * An empty cell shows no label and no colour: `null` always; 0 too, except for `weightedAvg`,
+     * where 0 is a real mean and an empty cell is `null` (AB#7956).
+     */
+    isEmptyCell(value: number | null | undefined): boolean;
+    /**
+     * Badge text of the widget's own time window (AB#7956), e.g. `Last 30 days`; `null` when the
+     * widget follows the board time filter or queries runtime data (the window binds stream data only).
+     */
+    timeWindowLabel(): string | null;
     xLabelContent: (e: {
         value: string;
     }) => string;
@@ -5310,17 +5782,23 @@ declare class HeatmapWidgetComponent implements DashboardWidget<HeatmapWidgetCon
      * Otherwise aggregates into hourly buckets.
      */
     private processHeatmapData;
+    /**
+     * True when `dateField` refers to the top-level timestamp of a stream-data row.
+     * Runtime rows are excluded so their date keeps coming only from the cells.
+     */
+    private static isRowTimestampField;
     /**
      * Detects the interval width in minutes from the first row with from+to.
      */
     private detectIntervalMinutes;
     /**
-     * Processes data into hourly buckets (original behavior).
+     * Processes data into hourly buckets. Hour and day follow the board time zone; a DST
+     * fall-back day keeps its repeated hour as its own row (`02:00 (2)`, AB#7956).
      */
     private processHourlyData;
     /**
      * Processes data into sub-hour interval buckets.
-     * Y-axis: hours (00:00..23:00), X-axis: interval labels (e.g. "00-15", "15-30", ...).
+     * Y-axis: hours (00:00..23:00, plus a repeated DST hour), X-axis: interval labels (e.g. "00-15", "15-30", ...).
      * For multi-day data, X-axis labels are prefixed with the date.
      */
     private processSubHourData;
@@ -5342,7 +5820,6 @@ declare class HeatmapWidgetComponent implements DashboardWidget<HeatmapWidgetCon
      * → amber, above → red.
      */
     private getThresholdColor;
-    private aggregate;
     /** Delegates to {@link toInstant} so naive wire timestamps are pinned to UTC (AB#4818). */
     private parseDate;
     private convertFiltersToDto;
@@ -5364,6 +5841,13 @@ interface HeatmapConfigResult extends WidgetConfigResult {
     dateEndField?: string;
     valueField?: string;
     aggregation: HeatmapAggregation;
+    /** `weightedAvg` only: the weight (count) column (AB#7956) */
+    weightField?: string;
+    /** The date field marks the bucket end; shift rows by {@link bucketWidthMinutes} (AB#7956) */
+    timestampIsBucketEnd?: boolean;
+    bucketWidthMinutes?: number;
+    /** Own relative time window that overrides the board time filter (AB#7956) */
+    timeWindow?: HeatmapTimeWindow;
     colorScheme: HeatmapColorScheme;
     colorMode?: HeatmapColorMode;
     thresholdTarget?: number;
@@ -5389,6 +5873,10 @@ declare class HeatmapConfigDialogComponent implements OnInit {
     initialDateEndField?: string;
     initialValueField?: string;
     initialAggregation?: HeatmapAggregation;
+    initialWeightField?: string;
+    initialTimestampIsBucketEnd?: boolean;
+    initialBucketWidthMinutes?: number;
+    initialTimeWindow?: HeatmapTimeWindow;
     initialColorScheme?: HeatmapColorScheme;
     initialColorMode?: HeatmapColorMode;
     initialThresholdTarget?: number;
@@ -5412,6 +5900,10 @@ declare class HeatmapConfigDialogComponent implements OnInit {
         value: string;
         label: string;
     }[];
+    timeWindowUnitOptions: {
+        value: RelativeTimeUnit;
+        label: string;
+    }[];
     colorModeOptions: {
         value: HeatmapColorMode;
         label: string;
@@ -5434,6 +5926,12 @@ declare class HeatmapConfigDialogComponent implements OnInit {
         dateEndField: string | undefined;
         valueField: string | undefined;
         aggregation: HeatmapAggregation;
+        weightField: string | undefined;
+        timestampIsBucketEnd: boolean;
+        bucketWidthMinutes: number | undefined;
+        useTimeWindow: boolean;
+        timeWindowValue: number | undefined;
+        timeWindowUnit: RelativeTimeUnit;
         colorScheme: HeatmapColorScheme;
         colorMode: HeatmapColorMode;
         thresholdTarget: number | undefined;
@@ -5444,6 +5942,8 @@ declare class HeatmapConfigDialogComponent implements OnInit {
         valueMultiplier: number;
     };
     get isValid(): boolean;
+    /** Why the AB#7956 options block saving, or `null`. */
+    get optionsError(): string | null;
     /** Entity selectors available on the current MeshBoard (for the scope picker). */
     get availableEntitySelectors(): EntitySelectorConfig[];
     get selectedQueryFamily(): QueryFamily | null;
@@ -5460,7 +5960,7 @@ declare class HeatmapConfigDialogComponent implements OnInit {
     onSave(): void;
     onCancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeatmapConfigDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeatmapConfigDialogComponent, "mm-heatmap-config-dialog", never, { "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialQueryFamily": { "alias": "initialQueryFamily"; "required": false; }; "initialIgnoreTimeFilter": { "alias": "initialIgnoreTimeFilter"; "required": false; }; "initialEntitySelectorId": { "alias": "initialEntitySelectorId"; "required": false; }; "initialDateField": { "alias": "initialDateField"; "required": false; }; "initialDateEndField": { "alias": "initialDateEndField"; "required": false; }; "initialValueField": { "alias": "initialValueField"; "required": false; }; "initialAggregation": { "alias": "initialAggregation"; "required": false; }; "initialColorScheme": { "alias": "initialColorScheme"; "required": false; }; "initialColorMode": { "alias": "initialColorMode"; "required": false; }; "initialThresholdTarget": { "alias": "initialThresholdTarget"; "required": false; }; "initialShowLegend": { "alias": "initialShowLegend"; "required": false; }; "initialLegendPosition": { "alias": "initialLegendPosition"; "required": false; }; "initialDecimalPlaces": { "alias": "initialDecimalPlaces"; "required": false; }; "initialCompactNumbers": { "alias": "initialCompactNumbers"; "required": false; }; "initialValueMultiplier": { "alias": "initialValueMultiplier"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeatmapConfigDialogComponent, "mm-heatmap-config-dialog", never, { "initialQueryRtId": { "alias": "initialQueryRtId"; "required": false; }; "initialQueryName": { "alias": "initialQueryName"; "required": false; }; "initialQueryFamily": { "alias": "initialQueryFamily"; "required": false; }; "initialIgnoreTimeFilter": { "alias": "initialIgnoreTimeFilter"; "required": false; }; "initialEntitySelectorId": { "alias": "initialEntitySelectorId"; "required": false; }; "initialDateField": { "alias": "initialDateField"; "required": false; }; "initialDateEndField": { "alias": "initialDateEndField"; "required": false; }; "initialValueField": { "alias": "initialValueField"; "required": false; }; "initialAggregation": { "alias": "initialAggregation"; "required": false; }; "initialWeightField": { "alias": "initialWeightField"; "required": false; }; "initialTimestampIsBucketEnd": { "alias": "initialTimestampIsBucketEnd"; "required": false; }; "initialBucketWidthMinutes": { "alias": "initialBucketWidthMinutes"; "required": false; }; "initialTimeWindow": { "alias": "initialTimeWindow"; "required": false; }; "initialColorScheme": { "alias": "initialColorScheme"; "required": false; }; "initialColorMode": { "alias": "initialColorMode"; "required": false; }; "initialThresholdTarget": { "alias": "initialThresholdTarget"; "required": false; }; "initialShowLegend": { "alias": "initialShowLegend"; "required": false; }; "initialLegendPosition": { "alias": "initialLegendPosition"; "required": false; }; "initialDecimalPlaces": { "alias": "initialDecimalPlaces"; "required": false; }; "initialCompactNumbers": { "alias": "initialCompactNumbers"; "required": false; }; "initialValueMultiplier": { "alias": "initialValueMultiplier"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 interface StatValue {
@@ -6391,6 +6891,12 @@ interface MeshBoardMessages {
      * 'Could not resolve the scope of "{label}" - widgets bound to it show no data.'
      */
     scopeResolutionFailed?: string;
+    /**
+     * Board notice for a dependent entity selector without pick while its leader has one (AB#7916):
+     * widgets bound to it show no data until a pick is made. `{label}` is replaced by the selector
+     * label. Default: 'Pick a {label} to see this data.'
+     */
+    scopePickRequired?: string;
 }
 /** Default texts of {@link MeshBoardMessages} (the list texts default inside `mm-list-view`). */
 declare const DEFAULT_MESHBOARD_MESSAGES: Required<Omit<MeshBoardMessages, 'tableList'>>;
@@ -6412,6 +6918,36 @@ declare const MESHBOARD_MESSAGES: InjectionToken<MeshBoardMessagesSource>;
 /** The resolved MeshBoard texts: defaults with the host layer on top (missing / null members keep the default). */
 declare function resolveMeshBoardMessages(messages: MeshBoardMessages | null | undefined): MeshBoardMessages & typeof DEFAULT_MESHBOARD_MESSAGES;
 
+/**
+ * What a host provides on {@link MESHBOARD_LANGUAGE} (AB#7655): the current UI language as a culture
+ * code (`de-AT`, `en-GB`, `de`), fixed or as a signal for apps that switch the language at runtime
+ * (the widgets follow it without reloading data). `null` / `undefined` / `''` = no language.
+ */
+type MeshBoardLanguageSource = string | Signal<string | null | undefined>;
+/**
+ * Optional: the host's current UI language. MeshBoard does not derive it from `LOCALE_ID` (that is
+ * static in many apps); a host that wants per-language texts in board configurations (table column
+ * `titles`, `valueLabels`) hands its language over once, via `provideMeshBoard({ language })`,
+ * `provideMeshBoardLanguage(language)` or this token directly. Not provided = the configured default
+ * texts (e.g. the column `title`).
+ *
+ * ```ts
+ * providers: [provideMeshBoard({ language: languageService.currentLanguage })] // Signal<string>
+ * ```
+ */
+declare const MESHBOARD_LANGUAGE: InjectionToken<MeshBoardLanguageSource>;
+/**
+ * Picks the text for `language` from a per-language map (AB#7655). Lookup order:
+ * 1. the exact culture or language (`de-AT`, `de`; case-insensitive);
+ * 2. a culture (`de-AT`) without an exact key: a key equal to its language part (`de`). A culture
+ *    never picks a sibling culture (`de-DE` does not take `de-AT`);
+ * 3. a bare language (`de`) without an exact key: the first authored key of that language
+ *    (`de-AT` in `{ 'en-GB': …, 'de-AT': …, 'de-DE': … }`), in the map's key order.
+ * Returns `undefined` when there is no language, no map or no match, so the caller applies its own
+ * fallback (e.g. the column `title`).
+ */
+declare function pickLocalizedText(texts: Readonly<Record<string, string>> | null | undefined, language: string | null | undefined): string | undefined;
+
 declare function registerDefaultWidgets(registry: WidgetRegistryService): void;
 /**
  * Provides the widget registry with all built-in widgets registered.
@@ -6445,6 +6981,13 @@ interface MeshBoardOptions {
      * table widget's list texts. Fixed object or signal. Absent = English.
      */
     messages?: MeshBoardMessagesSource;
+    /**
+     * The host's current UI language (AB#7655), provided as `MESHBOARD_LANGUAGE`: a culture code
+     * (`de-AT`) or a signal of it for apps that switch the language at runtime. Board configurations
+     * use it to pick per-language texts (table column `titles`, `valueLabels`). Absent = the default
+     * texts (column `title`); MeshBoard never falls back to `LOCALE_ID`.
+     */
+    language?: MeshBoardLanguageSource;
 }
 /**
  * Injection token for MeshBoard options
@@ -6479,6 +7022,11 @@ declare function provideMeshBoard(options?: MeshBoardOptions): EnvironmentProvid
  * without `provideMeshBoard()` — for apps that register the widgets lazily.
  */
 declare function provideMeshBoardMessages(messages: MeshBoardMessagesSource): EnvironmentProviders;
+/**
+ * Provides the host's UI language (`MESHBOARD_LANGUAGE`, AB#7655) without `provideMeshBoard()` —
+ * for apps that register the widgets lazily. A string or a signal (the widgets follow it).
+ */
+declare function provideMeshBoardLanguage(language: MeshBoardLanguageSource): EnvironmentProviders;
 /**
  * Provider function for registering custom widgets.
  * Use this to add your own widget types to MeshBoard.
@@ -6560,9 +7108,17 @@ declare class EntitySelectorEditorComponent {
     private readonly variableService;
     private readonly getEntitiesByCkTypeGQL;
     private readonly confirmationService;
+    private readonly cdr;
+    private readonly destroyRef;
+    private readonly injector;
     entitySelectors: EntitySelectorConfig[];
     /** Existing variable names from other sources (static variables, other selectors) for duplicate detection */
     existingVariableNames: string[];
+    /**
+     * The board's static variables (AB#7724): offered in the picker filter and
+     * substituted when the editor lists default entities and checks the default.
+     */
+    variables: MeshBoardVariable[];
     entitySelectorsChange: EventEmitter<EntitySelectorConfig[]>;
     /** Emits true when entering edit mode, false when leaving — allows parent to hide its own buttons */
     editingStateChange: EventEmitter<boolean>;
@@ -6578,15 +7134,25 @@ declare class EntitySelectorEditorComponent {
     protected editMappings: EntitySelectorAttributeMapping[];
     protected editShowInToolbar: boolean;
     protected editDefaultRtId: string;
-    protected editChildScopeTargetCkTypeId: string;
-    protected editChildScopeTargetCkTypeItem: CkTypeSelectorItem | null;
-    protected editChildScopeRoleId: string;
-    protected editChildScopeDirection: 'in' | 'out';
+    protected editScopeHops: EntitySelectorScopeHop[];
     protected editFollowsSelectorId: string;
     /** Why choosing the leader changed the form (CK type fixed, mappings/default cleared). */
     protected followNotice: string;
+    protected editFilters: FieldFilterItem[];
+    /** Filter rows a follower carries from hand-editing; ignored and dropped on save. */
+    protected followerFilterCount: number;
+    /** Result of the server check whether the default entity matches the filter. */
+    protected defaultFilterCheck: DefaultFilterCheck;
+    private readonly defaultCheckRequests;
+    protected editScopeSourceSelectorId: string;
+    /** Hops from the leader's CK type to this selector's CK type; the last target is fixed. */
+    protected editScopeSourceHops: EntitySelectorScopeHop[];
+    /** Result of the check whether the default entity is inside the leader's default pick. */
+    protected defaultScopeCheck: DefaultScopeCheck;
+    private readonly scopeCheckRequests;
     protected defaultEntityDataSource: RuntimeEntitySelectDataSource | null;
     protected defaultEntityDialogDataSource: RuntimeEntityDialogDataSource | null;
+    constructor();
     /**
      * Starts adding a new entity selector.
      */
@@ -6609,6 +7175,45 @@ declare class EntitySelectorEditorComponent {
     get followedByLabels(): string;
     /** Validation message of the "Follows" choice, or '' when it is valid. */
     get followError(): string;
+    /** Selectors that list only entities inside the edited selector (AB#7917). */
+    get dependents(): EntitySelectorConfig[];
+    /** "A and B" of the selectors depending on the edited one. */
+    get dependentsLabels(): string;
+    /** True when the Follows choice is locked: the selector is followed or has dependents and follows nobody. */
+    get isFollowsLocked(): boolean;
+    /** Selectors the edited one may list "inside": not followers, not dependent, not itself. */
+    get scopeSourceLeaderOptions(): EntitySelectorConfig[];
+    /** True when the stored leader is not among the selectable leaders (deleted, follower, dependent). */
+    get isScopeSourceLeaderUnavailable(): boolean;
+    /** The leader selector of the scope source, if it exists. */
+    get scopeSourceLeader(): EntitySelectorConfig | undefined;
+    /** Label of the scope source leader (label, else id). */
+    get scopeSourceLeaderLabel(): string;
+    /** Source type of hop 1: the leader's CK type. */
+    get scopeSourceLeaderCkTypeId(): string;
+    /** "Room" — the edited selector in texts. */
+    get editName(): string;
+    /** True when the "Inside the pick of" choice is locked: other selectors depend on this one (one level). */
+    get isScopeSourceLocked(): boolean;
+    /** Validation message of the scope source, or '' when it can be saved (or is dropped on save). */
+    get scopeSourceError(): string;
+    /**
+     * The scope source error as the section shows it: hop errors are already
+     * shown by the path editor next to the hop, so they are not repeated here.
+     */
+    get scopeSourceDisplayError(): string;
+    /** Maximum hop count of a path (getter: relative imports must not initialise fields). */
+    get maxScopeHops(): number;
+    /** Handles a change of the "Inside the pick of" choice. */
+    onScopeSourceChanged(leaderId: string): void;
+    /** Takes the hop list of the scope source path editor. */
+    onScopeSourceHopsChanged(hops: EntitySelectorScopeHop[]): void;
+    /** "Inside: Site (3 hops)" chip of a selector in the list, or ''. */
+    getScopeSourceSummary(selector: EntitySelectorConfig): string;
+    /** True when a selector's scope source cannot be used (list chip shown as an error). */
+    isInvalidScopeSource(selector: EntitySelectorConfig): boolean;
+    /** The edited selector as far as the scope source validation needs it. */
+    private formSelectorForValidation;
     /** True while the edited selector follows another one. */
     get isFollower(): boolean;
     /**
@@ -6633,14 +7238,10 @@ declare class EntitySelectorEditorComponent {
      * Opens the attribute selector dialog to pick attributes for variable mappings.
      */
     selectAttributes(): Promise<void>;
-    /**
-     * Handles child-scope target CK type selection.
-     */
-    onChildScopeCkTypeSelected(ckType: CkTypeSelectorItem): void;
-    /**
-     * Handles child-scope target CK type cleared.
-     */
-    onChildScopeCkTypeCleared(): void;
+    /** Takes the hop list of the child-scope editor (AB#7723). */
+    onScopeHopsChanged(hops: EntitySelectorScopeHop[]): void;
+    /** Validation message of the hop list, or '' when it can be saved. */
+    get scopeHopsError(): string;
     /**
      * Handles default entity selection from the entity picker.
      */
@@ -6649,6 +7250,20 @@ declare class EntitySelectorEditorComponent {
      * Handles default entity cleared.
      */
     onDefaultEntityCleared(): void;
+    /** Takes the rows of the picker filter editor (AB#7724). */
+    onFiltersChange(filters: FieldFilterItem[]): void;
+    /**
+     * Variables offered in filter values: the board's static variables and the
+     * variables other selectors map. The edited selector's own mappings are
+     * left out — they are filled from its own pick.
+     */
+    get filterVariables(): FilterVariable[];
+    /** "2 filters" chip of a selector in the list, or '' without filter. */
+    getFilterSummary(selector: EntitySelectorConfig): string;
+    /** "$a, $b" of the variables the default-entity check cannot substitute. */
+    get uncheckedVariablesText(): string;
+    /** Label of the leader the edited follower takes its pick from. */
+    get leaderLabel(): string;
     /**
      * Saves the current entity selector being edited.
      */
@@ -6688,9 +7303,193 @@ declare class EntitySelectorEditorComponent {
     getVariableNameError(mapping: EntitySelectorAttributeMapping): string;
     private generateSelectorId;
     private updateDefaultEntityDataSources;
+    private toFilterConfigs;
+    /**
+     * The filter rows that apply in the editor, with the board's static
+     * variables substituted. Rows whose value still names a variable without a
+     * value (e.g. one a selector pick fills at view time) are left out and
+     * reported in `unresolved`; the editor cannot know their value.
+     */
+    private resolvedEditorFilters;
+    /** Queues the (debounced) check whether the default entity matches the filter. */
+    private requestDefaultCheck;
+    /** Asks the server whether the entity is among the filtered ones (rtId + filter, first 1). */
+    private checkDefaultEntity;
+    /**
+     * Queues the (debounced) check whether the default entity lies inside the
+     * leader's default pick (AB#7917). Only for a valid scope source and when
+     * both selectors have a default; otherwise clears the result.
+     */
+    private requestScopeCheck;
+    /** Resolves the leader's default pick through the path and looks for the default entity. */
+    private checkDefaultInScope;
     private emitChange;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySelectorEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorEditorComponent, "mm-entity-selector-editor", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; "existingVariableNames": { "alias": "existingVariableNames"; "required": false; }; }, { "entitySelectorsChange": "entitySelectorsChange"; "editingStateChange": "editingStateChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorEditorComponent, "mm-entity-selector-editor", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; "existingVariableNames": { "alias": "existingVariableNames"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; }, { "entitySelectorsChange": "entitySelectorsChange"; "editingStateChange": "editingStateChange"; }, never, never, true, never>;
+}
+/**
+ * Outcome of the check whether a dependent selector's default entity lies
+ * inside its leader's default pick (AB#7917). Never blocks saving: `outside`
+ * warns, `error` says the check failed.
+ */
+type DefaultScopeCheck = {
+    state: 'none';
+} | {
+    state: 'inside';
+} | {
+    state: 'outside';
+} | {
+    state: 'error';
+};
+/**
+ * Outcome of the default-entity filter check (AB#7724). Never blocks saving:
+ * `mismatch` warns, `error` says the check failed, `unchecked` names the
+ * variables the editor cannot substitute.
+ */
+type DefaultFilterCheck = {
+    state: 'none';
+} | {
+    state: 'match';
+} | {
+    state: 'mismatch';
+} | {
+    state: 'error';
+} | {
+    state: 'unchecked';
+    variables: string[];
+};
+
+/** One association of a CK type as the "Association" dropdown offers it. */
+interface ScopeAssociationOption {
+    /** `<direction>|<roleId>|<baseTargetCkTypeId>`, or {@link OTHER_ASSOCIATION}. */
+    key: string;
+    roleId: string;
+    direction: 'in' | 'out';
+    /** Target type of the association in the CK metadata (base type for the target-type picker). */
+    baseTargetCkTypeId: string;
+    label: string;
+}
+/** Editor row of one hop. */
+interface HopRow {
+    roleId: string;
+    direction: 'in' | 'out';
+    targetCkTypeId: string;
+    targetItem: CkTypeSelectorItem | null;
+    /** Key of the chosen association, or {@link OTHER_ASSOCIATION} for free text. */
+    associationKey: string;
+}
+/**
+ * Hop list of an entity selector's child scope (AB#7723; wireframe agreed by
+ * Freya, AB#7723 comment 6625315). Each hop picks an association of its source
+ * type from the CK metadata (role + direction + base target in one entry, or
+ * "Other role…" for free text) and a target type restricted to types derived
+ * from the association's target. The source type of hop 1 is the selector's
+ * CK type, of every later hop the previous hop's target type. Hops can be
+ * added (at most {@link MAX_SCOPE_HOPS}), removed and moved up/down.
+ *
+ * Two-way bindable; emits the hops as configured (validation is the host's,
+ * see `scopeHopsValidationError`):
+ * ```html
+ * <mm-entity-selector-scope-path-editor
+ *   [sourceCkTypeId]="ckTypeId"
+ *   [(hops)]="hops">
+ * </mm-entity-selector-scope-path-editor>
+ * ```
+ */
+declare class EntitySelectorScopePathEditorComponent {
+    private readonly rolesGQL;
+    private readonly cdr;
+    hopsChange: EventEmitter<EntitySelectorScopeHop[]>;
+    private hopCards?;
+    protected rows: HopRow[];
+    protected readonly plusIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowUpIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly arrowDownIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly trashIcon: _progress_kendo_svg_icons.SVGIcon;
+    /**
+     * Intro text above the hop list. Unset = the child-scope text (AB#7723);
+     * the scope-source section of the selector editor passes its own (AB#7917).
+     */
+    description: string | null;
+    /** What the source of hop 1 is, shown after its type ("picked entity"). */
+    sourceDescription: string;
+    /** Text shown while there is no hop. Unset = the child-scope text. */
+    emptyText: string | null;
+    private _sourceCkTypeId;
+    private _lockedTargetCkTypeId;
+    private lastEmitted;
+    private readonly associations;
+    /** CK type of the picked entity — the source type of hop 1. */
+    set sourceCkTypeId(value: string | null | undefined);
+    get sourceCkTypeId(): string;
+    /**
+     * When set, the last hop's target type is fixed to this type (AB#7917: the
+     * scope source path always ends at the dependent selector's CK type). The
+     * last hop then shows the type read-only, new hops are inserted before it,
+     * and it cannot be moved; removing it makes the previous hop the fixed one.
+     */
+    set lockedTargetCkTypeId(value: string | null | undefined);
+    get lockedTargetCkTypeId(): string;
+    /** The configured hops (one-hop form = one hop). */
+    set hops(value: EntitySelectorScopeHop[] | null | undefined);
+    /** True when the last hop's target type is fixed ({@link lockedTargetCkTypeId}). */
+    get isLocked(): boolean;
+    /** True when hop `index` is the last hop and its target type is fixed. */
+    isLockedHop(index: number): boolean;
+    /** True when hop `index` offers "move up" (a fixed last hop stays last). */
+    canMoveUp(index: number): boolean;
+    /** True when hop `index` offers "move down" (nothing moves below a fixed last hop). */
+    canMoveDown(index: number): boolean;
+    /** Maximum hop count (getter: relative imports must not initialise fields, see CLAUDE.md). */
+    get maxHops(): number;
+    get canAddHop(): boolean;
+    /** "Test/Site → Test/System → Test/Device". */
+    get pathLabel(): string;
+    /** True when the association metadata of any shown source type could not be loaded. */
+    get metadataFailed(): boolean;
+    /** Source type of hop `index`. */
+    sourceTypeOf(index: number): string;
+    /** Dropdown entries of hop `index`: the source type's associations plus "Other role…". */
+    associationOptions(index: number): ScopeAssociationOption[];
+    /** True when hop `index` offers the association dropdown (metadata loaded with ≥1 association). */
+    hasAssociationList(index: number): boolean;
+    /** True when hop `index` shows the free-text role and direction fields. */
+    isFreeText(index: number): boolean;
+    /** Base type the target-type picker of hop `index` is restricted to (undefined = any type). */
+    baseTargetOf(index: number): string | undefined;
+    /**
+     * Warning of hop `index` when its role is not an association of its (new)
+     * source type — after a reorder, a removal or a changed earlier target. The
+     * values are kept; it does not block saving.
+     */
+    associationWarning(index: number): string;
+    /** Validation message of hop `index`: an incomplete hop blocks saving (see `scopeHopsValidationError`). */
+    hopError(index: number): string;
+    isRoleInvalid(index: number): boolean;
+    isTargetInvalid(index: number): boolean;
+    addHop(): void;
+    removeHop(index: number): void;
+    moveHop(index: number, delta: -1 | 1): void;
+    onAssociationChanged(index: number, key: string): void;
+    onRoleChanged(index: number, roleId: string): void;
+    onDirectionChanged(index: number, direction: 'in' | 'out'): void;
+    onTargetSelected(index: number, ckType: CkTypeSelectorItem): void;
+    onTargetCleared(index: number): void;
+    /** Sets the last hop's target type to the fixed type (no-op without a lock). */
+    private applyLock;
+    private emit;
+    private loadOf;
+    /**
+     * Matches every hop's role/direction to an entry of its source type's
+     * associations (loading missing metadata); a hop whose association is not
+     * listed switches to "Other role…" with its values kept.
+     */
+    private syncAssociationKeys;
+    private loadAssociations;
+    /** Keeps the keyboard focus on a moved hop (wireframe change 4). */
+    private focusHop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySelectorScopePathEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorScopePathEditorComponent, "mm-entity-selector-scope-path-editor", never, { "description": { "alias": "description"; "required": false; }; "sourceDescription": { "alias": "sourceDescription"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "sourceCkTypeId": { "alias": "sourceCkTypeId"; "required": false; }; "lockedTargetCkTypeId": { "alias": "lockedTargetCkTypeId"; "required": false; }; "hops": { "alias": "hops"; "required": false; }; }, { "hopsChange": "hopsChange"; }, never, never, true, never>;
 }
 
 /**
@@ -6708,18 +7507,38 @@ interface EntitySelectorClearEvent {
 }
 /**
  * Toolbar component that renders entity select inputs for each configured entity selector.
- * Creates data sources per CK type and emits selection/clear events.
+ * Creates data sources per CK type, picker filter (AB#7724) and picker scope (AB#7915) and emits
+ * selection/clear events.
  */
-declare class EntitySelectorToolbarComponent implements OnChanges {
+declare class EntitySelectorToolbarComponent implements OnChanges, OnDestroy {
     private readonly getEntitiesByCkTypeGQL;
+    private readonly variableService;
     entitySelectors: EntitySelectorConfig[];
+    /**
+     * Board variables substituted into the selectors' picker filters (AB#7724),
+     * the same substitution widget filters get.
+     */
+    variables: MeshBoardVariable[];
+    /**
+     * Picker scopes of dependent selectors (AB#7915), keyed by selector id
+     * (`MeshBoardStateService.pickerScopes`). No entry = the leader has no pick.
+     */
+    pickerScopes: Record<string, EntitySelectorScopeState>;
     entitySelected: EventEmitter<EntitySelectorEvent>;
     entityCleared: EventEmitter<EntitySelectorClearEvent>;
     private dataSourceCache;
     private dialogDataSourceCache;
     protected selectorDataSources: Map<string, RuntimeEntitySelectDataSource>;
     protected selectorDialogDataSources: Map<string, RuntimeEntityDialogDataSource>;
+    protected selectorMessages: Map<string, Partial<EntitySelectInputMessages>>;
+    private filteredSelectorIds;
+    private readonly settledPickers$;
     ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Texts of the selector's picker: a filtered picker explains its empty list (AB#7724). */
+    getMessages(selector: EntitySelectorConfig): Partial<EntitySelectInputMessages>;
+    /** Title of the selector's search dialog; marks a filtered picker (AB#7724). */
+    getDialogTitle(selector: EntitySelectorConfig): string;
     /**
      * True when the selector renders a picker. Hidden selectors and followers
      * (AB#7722) never do; a follower's pick is derived from its leader.
@@ -6742,11 +7561,33 @@ declare class EntitySelectorToolbarComponent implements OnChanges {
      */
     onEntityCleared(selectorId: string): void;
     /**
-     * Creates or retrieves cached data sources for each selector.
+     * Creates or retrieves cached data sources for each selector. Selectors of
+     * the same CK type, the same resolved filter and the same picker scope share
+     * their data sources; a selector without filter and scope source uses the
+     * plain query, exactly as before AB#7724. The cache key changes with the
+     * picker scope (AB#7915), so a leader change gives the dependent fresh data
+     * sources. Entries no selector uses any more are dropped, so the caches never
+     * outgrow the current selectors.
      */
     private updateDataSources;
+    /**
+     * The query service of a picker: filter rows (AB#7724) plus, for a dependent
+     * selector, the picker scope `rtId IN (…)` (AB#7915). Empty and failed scopes
+     * list nothing without a request; a pending scope waits until it settled.
+     */
+    private pickerQuery;
+    /** The query of `selectorId` once its picker scope is no longer pending (`null` = list nothing). */
+    private settledPicker;
+    /**
+     * Picker texts (wording agreed with the Studio PO): a dependent picker with
+     * nothing in scope or a failed scope says so right away (also before the
+     * user types); a filtered picker explains an empty search result (AB#7724).
+     */
+    private pickerMessages;
+    /** Number of cached data source pairs (for tests). */
+    get cachedDataSourceCount(): number;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<EntitySelectorToolbarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorToolbarComponent, "mm-entity-selector-toolbar", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; }, { "entitySelected": "entitySelected"; "entityCleared": "entityCleared"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntitySelectorToolbarComponent, "mm-entity-selector-toolbar", never, { "entitySelectors": { "alias": "entitySelectors"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "pickerScopes": { "alias": "pickerScopes"; "required": false; }; }, { "entitySelected": "entitySelected"; "entityCleared": "entityCleared"; }, never, never, true, never>;
 }
 
 /**
@@ -6770,6 +7611,28 @@ interface WidgetPlacement {
     rowSpan: number;
 }
 
+/**
+ * The period a host page sets on an embedded MeshBoard (`mm-meshboard-view [timeRange]`, AB#7582):
+ * two exact instants, half-open `[from, to)`. A string must be an RFC 3339 date-time with an
+ * explicit offset - see {@link parseHostTimeRange}.
+ */
+interface MeshBoardHostTimeRange {
+    from: Date | string;
+    to: Date | string;
+}
+/**
+ * Who controls the board's period: `board` (default) shows the board's own time-range picker;
+ * `host` hides the picker and its reset button because the host page owns the period.
+ */
+type MeshBoardTimeFilterControl = 'board' | 'host';
+/**
+ * Parses the host's `timeRange` input. `undefined`/`null` = the host sets no period.
+ * Never snaps or converts: the instants are taken as given. `Date` objects are accepted as they
+ * are; strings must be RFC 3339 with an offset, e.g. `2026-03-28T05:00:00Z` or
+ * `2026-03-28T06:00:00+01:00` (see {@link RFC3339}).
+ */
+declare function parseHostTimeRange(value: MeshBoardHostTimeRange | null | undefined): HostTimeRangeState | undefined;
+
 interface WidgetPositionUpdate {
     id: string;
     title: string;
@@ -6878,6 +7741,41 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     readonly chrome: _angular_core.InputSignal<MeshBoardChrome | undefined>;
     private readonly routeChrome;
     protected readonly effectiveChrome: _angular_core.Signal<MeshBoardChrome>;
+    /**
+     * The period set by the host page (AB#7582): two exact instants, half-open `[from, to)`, as
+     * `Date` objects or ISO 8601 strings with a zone designator. While set (and the board's time
+     * filter is enabled) the view publishes exactly these instants as `$timeRangeFrom` /
+     * `$timeRangeTo` and as the stream-data window - no day snapping, no zone conversion - and
+     * ignores the `tf_*` query parameters and the stored/default selection. It writes no `tf_*`
+     * parameters and causes no unsaved changes. A change reloads the widgets once; `undefined`
+     * returns the board to its own selection. Day rules (e.g. a 06:00 gas day) belong to the host.
+     * An invalid range (unparseable, or `from >= to`) sends no stream-data query and logs one
+     * console error. A board with the time filter disabled ignores the input.
+     */
+    readonly timeRange: _angular_core.InputSignal<MeshBoardHostTimeRange | undefined>;
+    /**
+     * Who controls the period: `board` (default, unchanged behaviour) shows the board's time-range
+     * picker; `host` hides the picker and its reset button - entity selectors and actions stay.
+     * While `timeRange` is set the picker is hidden and its events are ignored either way.
+     */
+    readonly timeFilterControl: _angular_core.InputSignal<MeshBoardTimeFilterControl>;
+    /** The parsed `timeRange` input; `undefined` = the host sets no period. */
+    protected readonly parsedHostTimeRange: _angular_core.Signal<HostTimeRangeState | undefined>;
+    /** True while the host owns the period (a valid or an invalid `timeRange` is set). */
+    protected readonly isHostTimeRangeActive: _angular_core.Signal<boolean>;
+    /** Whether the board's own time-range picker (and its reset button) is rendered. */
+    protected readonly showTimeRangePicker: _angular_core.Signal<boolean>;
+    /** The host range last applied to the state service (to reload only on a real change). */
+    private appliedHostTimeRange;
+    /** The invalid host range already reported, so a board switch does not log it again. */
+    private reportedInvalidHostTimeRange;
+    /**
+     * Set once the host has owned the period: the `tf_*` parameters of the URL this view was opened
+     * with are stale from then on and are not applied again when `timeRange` goes back to undefined.
+     */
+    private hostHasOwnedPeriod;
+    /** Set in ngOnDestroy; the async initial load stops touching shared state after it (AB#7582). */
+    private destroyed;
     protected readonly meshBoardPageLink: _angular_core.Signal<string>;
     protected readonly hasWidgets: _angular_core.Signal<boolean>;
     /** Widgets shown: outside edit mode those that reported "nothing for this viewer" are collapsed (AB#5558). */
@@ -6900,6 +7798,10 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     private readonly _urlTimeSelection;
     protected readonly initialTimeSelection: _angular_core.Signal<TimeRangeSelection$1 | undefined>;
     protected readonly entitySelectorsConfig: _angular_core.Signal<EntitySelectorConfig[]>;
+    /** Picker scopes of dependent selectors (AB#7915). */
+    protected readonly pickerScopes: _angular_core.Signal<Record<string, EntitySelectorScopeState>>;
+    /** Board variables substituted into the selectors' picker filters (AB#7724). */
+    protected readonly boardVariables: _angular_core.Signal<_meshmakers_octo_meshboard.MeshBoardVariable[]>;
     protected readonly hasEntitySelectors: _angular_core.Signal<boolean>;
     protected readonly unselectedToolbarSelectors: _angular_core.Signal<EntitySelectorConfig[]>;
     /**
@@ -6922,7 +7824,12 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * fail with a NavigationError (AB#4457).
      */
     private updateUrlWithRtId;
-    /** The active time-filter selection to mirror into the URL, or null when the filter is off. */
+    /**
+     * The active time-filter selection to mirror into the URL, or null when the filter is off or
+     * the host owns the period or controls the filter (AB#7582: the view then writes no tf_*
+     * parameters; with `timeFilterControl='host'` and no `timeRange` the board selection still
+     * applies, but the URL is the host's).
+     */
     private activeTimeFilterSelection;
     ngOnInit(): Promise<void>;
     /**
@@ -6946,8 +7853,22 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     /**
      * Initializes time filter variables based on URL query params or stored selection.
      * URL params take precedence over stored selection to support page reload.
+     * A period set by the host (`timeRange`, AB#7582) takes precedence over both.
      */
     private initializeTimeFilterVariables;
+    /**
+     * Hands the host period to the state service and publishes `$timeRangeFrom` / `$timeRangeTo`
+     * as exactly its instants (AB#7582). Returns true while the host owns the period, so the
+     * caller skips the board's own selection. With the time filter disabled the period is only
+     * stored (the state service ignores it then) and nothing is logged.
+     */
+    private applyHostTimeRange;
+    /**
+     * Applies a change of the `timeRange` input after the initial load (AB#7582): the host period,
+     * or the board's own selection again when the input went back to `undefined`. Reloads the
+     * widgets once; an equal period (same instants) changes nothing.
+     */
+    private onHostTimeRangeChanged;
     /**
      * Recomputes the active time-filter range from the current selection on the
      * board's (possibly just-changed) timezone mode and republishes the
@@ -7007,17 +7928,80 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * Programmatically sets an entity selector value from outside the component.
      * Use this when the host application controls entity selection (e.g., with meshBoardHideEntitySelectors).
      * Resolves entity attributes, sets variables, and refreshes widgets.
+     *
+     * Dependent selectors (AB#7916): an rtId outside the dependent's picker scope
+     * (the leader's pick) is rejected with a console warning and nothing
+     * re-queries. On a leader the leader-change rules apply: each dependent keeps
+     * its pick if it is in the new scope, else its default if that is, else it
+     * has no pick; widgets refresh once for the whole change.
      */
     setEntitySelector(selectorId: string, rtId: string, displayName?: string): Promise<void>;
     /**
      * Programmatically clears an entity selector value from outside the component.
+     * Clearing a leader keeps its dependents' picks (AB#7916); clearing a
+     * dependent while its leader has a pick leaves its widgets without data
+     * until a new pick is made.
      */
     clearEntitySelector(selectorId: string): void;
     /**
      * Clears one selector's pick, variables and scope state. Without a pick bound
-     * widgets fall back to the persisted scope (AB#7721).
+     * widgets fall back to the persisted scope (AB#7721) — except a dependent
+     * selector (or a follower of one without pick) while the leader has a pick:
+     * its widgets show no data and the view asks for a pick (AB#7916).
      */
     private clearSelectorPick;
+    /**
+     * True when the selector — having no pick — must show no data instead of
+     * the persisted scope (AB#7916): it is a valid dependent whose leader has a
+     * pick (the dependent has a picker scope), or a follower of such a dependent
+     * while the dependent has no pick either.
+     */
+    private needsPickWithoutOwnPick;
+    /** True when the selector has a usable scope source (AB#7915). */
+    private isDependent;
+    /**
+     * A dependent may only be picked inside its picker scope (AB#7916). While the
+     * scope resolves the check waits for it; a scope overtaken meanwhile is read
+     * again.
+     */
+    private acceptsDependentPick;
+    /** Starts a new change of `selectorId`'s pick and returns its number (AB#7916). */
+    private beginLeaderChange;
+    /** True while no newer change of `selectorId`'s pick has started. */
+    private isCurrentLeaderChange;
+    /**
+     * Picks `rtId` on a selector that may lead dependents (AB#7915/AB#7916). In
+     * one synchronous step it marks the selector and its followers pending and
+     * starts the dependents' picker scopes and pick decisions
+     * ({@link settleDependentsOf}); then resolves the selector's own variables
+     * and scope. `displayName` settles with the picked entity's display name,
+     * `dependents` once every dependent's pick is decided, with the ids of the
+     * dependents whose pick changed. `initialPicks` (board load) replaces the
+     * dependents' current picks.
+     */
+    private pickWithDependents;
+    /**
+     * The leader `leaderId` was picked (`leaderRtId`): decides each dependent's
+     * pick (AB#7916). Synchronously, each dependent's picker scope becomes
+     * pending; a dependent with a current pick or a default is also marked
+     * pending together with its followers, so bound widgets show loading and
+     * never the old pick's data. Once the picker scope resolved, the pick is
+     * {@link nextDependentPick}: kept if in scope, else the default if in scope,
+     * else none. Without pick the dependent's widgets show no data with a
+     * "pick" notice — a failed picker scope shows the scope-failed notice
+     * instead. A decision overtaken by a newer leader change or a leader clear
+     * is dropped. Resolves with the ids of the dependents whose pick changed.
+     */
+    private settleDependentsOf;
+    /**
+     * The leader `leaderId` loses its pick (`clear` clears it, which also drops
+     * the dependents' picker scopes): dependents keep their picks (AB#7916). A
+     * dependent without pick goes back to the persisted scope (AB#7721), and so
+     * do its followers that needed a pick; a dependent whose pick was still being
+     * decided resolves its current pick again. Returns a promise for those
+     * resolutions, or `null` when there are none.
+     */
+    private releaseDependentsOf;
     /**
      * The leader `leaderId` has no pick any more: each of its followers resolves
      * its own `defaultRtId`, or — without one — has no pick and no scope
@@ -7037,11 +8021,36 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
         selectorId: string;
         message: string;
     }[]>;
+    /**
+     * One notice per dependent selector without pick while its leader has one
+     * (AB#7916): "Pick a <label> to see this data.". Followers of such a
+     * dependent show no data too, but the notice names the selector to pick.
+     */
+    protected readonly scopePickRequiredNotices: _angular_core.Signal<{
+        selectorId: string;
+        message: string;
+    }[]>;
     /**
      * Per-selector sequence number of the latest scope resolution, so a slower
      * resolution of an earlier pick never overwrites the scope of a newer pick.
      */
     private readonly scopeRequestSeq;
+    /**
+     * Per-dependent sequence number of the latest picker-scope resolution
+     * (AB#7915): a late resolution of an earlier leader pick is discarded.
+     */
+    private readonly pickerScopeSeq;
+    /** The latest picker-scope resolution of each dependent (AB#7916), awaited by a host pick. */
+    private readonly pickerScopeResolutions;
+    /**
+     * Per-selector number of the latest pick change (AB#7916): the widget
+     * refresh and URL write of a change overtaken by a newer one are skipped.
+     */
+    private readonly leaderChangeSeq;
+    /** Dependents whose pick is being decided after a leader change (AB#7916). */
+    private readonly decidingDependents;
+    /** Set when the board load dropped an out-of-scope dependent pick from the URL or route data (AB#7916). */
+    private entitySelectorUrlNeedsRewrite;
     /**
      * Handles time range change from the time range picker.
      * No-op: refresh is triggered by onTimeSelectionChange to ensure variables are updated first.
@@ -7151,17 +8160,34 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     /**
      * Handles entity selection from the entity selector toolbar.
      * Fetches entity attributes, sets variables, syncs to URL, and refreshes widgets.
+     * On a leader the dependents' picks are decided first (AB#7916) and the
+     * widgets refresh once for the whole change; a dependent only accepts an
+     * rtId inside its picker scope.
      */
     onEntitySelectorSelected(event: EntitySelectorEvent): Promise<void>;
     /**
      * Handles entity cleared from the entity selector toolbar.
-     * Clears variables, syncs URL, and refreshes widgets.
+     * Clears variables, syncs URL, and refreshes widgets. Clearing a leader keeps
+     * its dependents' picks (AB#7916).
      */
     onEntitySelectorCleared(event: EntitySelectorClearEvent): Promise<void>;
     /**
      * Initializes entity selectors from URL params, route data, or defaults.
+     *
+     * Leaders resolve first (AB#7916): a dependent whose leader has a pick gets
+     * its pick decided against the picker scope — an initial pick outside it is
+     * dropped (default if in scope, else no pick); one dropped from the URL or
+     * route data is logged once and the URL is rewritten. Widgets refresh once,
+     * after every pick is decided.
      */
     private initializeEntitySelectors;
+    /**
+     * Logs (once per board load) each dependent whose URL or route-data pick was
+     * dropped because it is outside the leader's pick, and marks the URL for a
+     * rewrite (AB#7916). A dropped `defaultRtId` is not reported: it never was
+     * in the URL.
+     */
+    private reportDroppedInitialPicks;
     /**
      * The initial pick of each entity selector. Priority: route data > URL
      * params > defaultRtId. Selectors without a pick are left out.
@@ -7181,6 +8207,24 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * Selectors without a pick stay without scope state (persisted scope).
      */
     private primeEntitySelectorScopes;
+    /**
+     * Picker scopes of dependent selectors right after a board loaded (AB#7915):
+     * a dependent whose leader has an initial pick is pending (its picker lists
+     * nothing until the scope resolved); an invalid scope source is failed and
+     * logs one warning per board load (the state is cleared on board switch, so
+     * the guard on an existing state makes this idempotent).
+     */
+    private primePickerScopes;
+    /**
+     * Resolves the picker scope of `dependent` from its leader's pick `rtId`
+     * (AB#7915): marks it pending synchronously, then walks `scopeSource.path`
+     * with `resolveScopePath` (one batched request per hop) and stores the
+     * distinct rtIds of the last hop — `[]` when the pick reaches nothing. A
+     * failing hop is a failed picker scope (logged once). Resolves with the
+     * stored state, or `null` when a newer leader pick (or a clear) overtook it.
+     * Never rejects.
+     */
+    private resolvePickerScope;
     /**
      * Resolves variables for an entity selector by fetching entity attributes,
      * then its stream-data scope.
@@ -7201,10 +8245,16 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * Resolves the set of source rtIds that a stream-data widget bound to this
      * selector should be scoped to, and caches them on the state service.
      *
-     * When the selector defines a {@link EntitySelectorChildScope}, the picked
-     * entity's children of `targetCkTypeId` reached via `roleId`/`direction`
-     * become the scope (e.g. MeteringPoint → its EnergyMeasurement rtIds). With
-     * no childScope, the picked entity's own rtId is the scope (direct keying).
+     * - No {@link EntitySelectorChildScope}: the picked entity's own rtId is the
+     *   scope (direct keying).
+     * - One-hop form (top-level fields): the picked entity's targets of
+     *   `targetCkTypeId` reached via `roleId`/`direction` (e.g. MeteringPoint →
+     *   its EnergyMeasurement rtIds) — exactly as before AB#7723.
+     * - `path` (AB#7723): hop by hop, each hop one batched request over all
+     *   entities the previous hop reached; the scope is the distinct rtIds of the
+     *   last hop. An empty hop ends the resolution with an empty scope; a failed
+     *   hop, or an invalid path (more than 5 hops, a hop without role or target
+     *   type), is a failed scope (AB#7721).
      */
     private resolveEntitySelectorScopeRtIds;
     /**
@@ -7219,6 +8269,8 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      * Format: es_<selectorId>=<rtId>
      */
     private writeEntitySelectorsToUrl;
+    /** The `es_<selectorId>` query parameters of the current picks (`null` = remove). */
+    private entitySelectorUrlParams;
     /**
      * Reads entity selector selections from URL query parameters.
      * Returns a map of selectorId -> rtId.
@@ -7235,7 +8287,7 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
      */
     saveChanges(): Promise<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardViewComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardViewComponent, "mm-meshboard-view", never, { "headerMode": { "alias": "headerMode"; "required": false; "isSignal": true; }; "chrome": { "alias": "chrome"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardViewComponent, "mm-meshboard-view", never, { "headerMode": { "alias": "headerMode"; "required": false; "isSignal": true; }; "chrome": { "alias": "chrome"; "required": false; "isSignal": true; }; "timeRange": { "alias": "timeRange"; "required": false; "isSignal": true; }; "timeFilterControl": { "alias": "timeFilterControl"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -9097,5 +10149,5 @@ declare function pipelineExecutionInputs(children: (unknown | null)[] | null | u
  */
 declare function countPipelineExecutions(pipelines: PipelineExecutionInput[], now?: number): PipelineExecutionCounts;
 
-export { ADAPTER_OFFLINE_GRACE_MS, ATTENTION_SEVERITY_ORDER, AdaptersAttentionProvider, AddWidgetDialogComponent, AiInsightsConfigDialogComponent, AiInsightsService, AiInsightsWidgetComponent, AlertBannerConfigDialogComponent, AlertBannerWidgetComponent, AlertListConfigDialogComponent, AlertListWidgetComponent, AssociationsConfigDialogComponent, AttentionListConfigDialogComponent, AttentionListWidgetComponent, AutoRefreshTimerService, BUILT_IN_ATTENTION_PROVIDERS, BarChartConfigDialogComponent, BarChartWidgetComponent, BlueprintUpdatesAttentionProvider, COCKPIT_ADAPTER_LIMIT, COCKPIT_ATTENTION_PROVIDERS, COCKPIT_BLUEPRINT_CATALOG_LIMIT, COCKPIT_CHILD_TENANT_IDS, COCKPIT_DATA_FLOW_LIMIT, COCKPIT_EXPLAIN_HANDLER, COCKPIT_FAILED_EXECUTIONS_OPTIONS, COCKPIT_KPI_GATES, COCKPIT_KPI_SLOW_LOADING_MS, COCKPIT_LINK_RESOLVER, COCKPIT_RECENT_ITEMS, COCKPIT_ROLES, COCKPIT_SERVICE_NAMES, COCKPIT_VERSION_SOURCE, COCKPIT_VIEWER_ACCESS, COCKPIT_WIDGET_MESSAGES, COCKPIT_WIDGET_TYPES, CkModelsResolveFailedAttentionProvider, CockpitAdapterStatesService, CockpitAttentionService, CockpitBlueprintStatusService, CockpitChildTenantsService, CockpitCkModelStatesService, CockpitContextService, CockpitDataFlowExecutionsService, CockpitKpiConfigDialogComponent, CockpitKpiService, CockpitKpiWidgetComponent, CockpitServiceHealthService, DAY_MS, DEFAULT_ATTENTION_MAX_ITEMS, DEFAULT_COCKPIT_WIDGET_MESSAGES, DEFAULT_FAILED_EXECUTIONS_OPTIONS, DEFAULT_MESHBOARD_MESSAGES, DEFAULT_RECENT_ITEMS_MAX, DEFAULT_TIME_ZONE_MODE, DashboardDataService, DashboardGridService, EditModeStateService, EditWidgetDialogComponent, EntityAssociationsWidgetComponent, EntityCardConfigDialogComponent, EntityCardWidgetComponent, EntityDetailDialogComponent, EntitySelectorEditorComponent, EntitySelectorToolbarComponent, FALLBACK_SERIES_COLORS, FailedExecutionsAttentionProvider, FeaturesNotInstalledAttentionProvider, GaugeConfigDialogComponent, GaugeWidgetComponent, HISTOGRAM_HOURS, HOUR_MS, HeatmapConfigDialogComponent, HeatmapWidgetComponent, KPI_ERROR_TEXT, KpiConfigDialogComponent, KpiWidgetComponent, LazyMarkdownComponent, LineChartConfigDialogComponent, LineChartWidgetComponent, MAX_RECENT_ITEMS, MESHBOARD_CHROME_ROUTE_DATA, MESHBOARD_DESCRIPTION_MARKER, MESHBOARD_EDIT_QUERY_PARAM, MESHBOARD_HEADER_MODE_ROUTE_DATA, MESHBOARD_LABEL_RESOLVER, MESHBOARD_MESSAGES, MESHBOARD_OPTIONS, MESHBOARD_TENANT_ID_PROVIDER, MarkdownConfigDialogComponent, MarkdownWidgetComponent, MeshBoardDataService, MeshBoardGridService, MeshBoardManagerDialogComponent, MeshBoardPersistenceService, MeshBoardSettingsDialogComponent, MeshBoardSettingsResult, MeshBoardStateService, MeshBoardViewComponent, NOT_AVAILABLE_TEXT, PieChartConfigDialogComponent, PieChartWidgetComponent, QueryExecutorService, QuerySelectorComponent, RecentItemsConfigDialogComponent, RecentItemsWidgetComponent, RuntimeEntitySelectorComponent, SERVICE_MANAGED_BLUEPRINT_PREFIX, STATE_STATUS_BY_KEY, ServiceHealthConfigDialogComponent, ServiceHealthWidgetComponent, ServicesHealthAttentionProvider, StatsGridConfigDialogComponent, StatsGridWidgetComponent, StatusIndicatorConfigDialogComponent, StatusIndicatorWidgetComponent, StatusListConfigDialogComponent, StatusListWidgetComponent, SummaryCardConfigDialogComponent, SummaryCardWidgetComponent, TableConfigDialogComponent, TableWidgetComponent, TableWidgetDataSourceDirective, UnregisteredPoolsAttentionProvider, WidgetFactoryService, WidgetGroupComponent, WidgetGroupConfigDialogComponent, WidgetNotConfiguredComponent, WidgetRegistryService, adapterKpi, adaptersInError, adaptersOffline, blueprintUpdatesKpi, buildHourlyHistogram, categoryStatus, chartSeriesColors, ckModelKpi, classifyQuery, compareBlueprintVersions, compareMeshBoardNavigation, countFlowExecutions, countLabel, countPipelineExecutions, emptyQueryExecutionResult, enabledButNotInstalled, executionKpi, failedExecutionsSeverity, formatCockpitMessage, formatCount, humanizeCategory, isAdapterAtRest, isAdapterExpectedToRun, isAdapterOnline, isCockpitWidgetType, isMeshBoardChrome, isMeshBoardHeaderMode, isServiceConfigured, joinEncodedDescription, kpiKindOf, latestStatisticsUpdate, legacyCockpitLinkTarget, loadNgxMarkdown, nameList, newMeshBoardConfig, normalizeNavigation, observeThemeChanges, pipelineExecutionInputs, plural, provideCockpitWidgetHost, provideCockpitWidgets, provideDefaultWidgets, provideMeshBoard, provideMeshBoardMessages, provideProcessWidget, provideWidgetRegistrations, queryFamily, readMeshBoardNavigation, recentRelativeTime, registerCockpitWidgets, registerDefaultWidgets, registerProcessWidget, resolveChartColor, resolveCockpitWidgetMessages, resolveMeshBoardChrome, resolveMeshBoardHeaderMode, resolveMeshBoardLabel, resolveMeshBoardMessages, selectProviders, serviceStateText, servicesHealthKpi, sortAttentionFindings, sparklineGeometry, splitBlueprintId, splitEncodedDescription, statusColor, summarizeAdapterOnline, tenantCountKpi, toBlueprintStatus, toServiceHealthStatus, truncationNote, versionKpi, withMeshBoardNavigation };
-export type { AdapterOnlineFields, AdapterOnlineSummary, AdapterStatusWidgetConfig, AggregationDataSource, AggregationQuery, AggregationType, AiInsightsConfigResult, AiInsightsWidgetConfig, AlertBannerConfigResult, AlertBannerWidgetConfig, AlertListConfigResult, AlertListWidgetConfig, AnyWidgetConfig, AssociationsConfigResult, AttentionContext, AttentionFinding, AttentionLink, AttentionListConfigResult, AttentionListWidgetConfig, AttentionProvider, AttentionProviderInfo, AttentionSeverity, AttentionState, BarChartColorThreshold, BarChartConfigResult, BarChartSeries, BarChartType, BarChartWidgetConfig, BaseWidgetConfig, BlueprintUpdatesWidgetConfig, CategoryStatus, CategoryValueItem, ChartReferenceLine, CkModelStateWidgetConfig, CkQueryResult, CkQueryTarget, CkTypeAttributeInfo, CockpitAdapterState, CockpitAdapterStates, CockpitBlueprintStatus, CockpitBlueprintUpdate, CockpitChildTenants, CockpitCkModelCounts, CockpitDataFlowExecutions, CockpitDataFlowRow, CockpitExecutionCounts, CockpitExplainHandler, CockpitExplainTarget, CockpitKpi, CockpitKpiConfigResult, CockpitKpiKind, CockpitKpiResult, CockpitKpiStatus, CockpitKpiWidgetConfig, CockpitKpiWidgetOptions, CockpitLinkQueryParams, CockpitLinkResolver, CockpitLinkTarget, CockpitRecentItem, CockpitRecentItemKind, CockpitRecentItemsSource, CockpitResolvedLink, CockpitRouteLinkTarget, CockpitServiceHealth, CockpitServiceHealthStatus, CockpitServiceKey, CockpitVersionEntry, CockpitVersionSource, CockpitViewerAccess, CockpitWidgetHost, CockpitWidgetMessages, CockpitWidgetMessagesSource, CockpitWidgetType, ConfigDialogResult, ConfigResultApplier, ConstructionKitQueryDataSource, DashboardConfig, DashboardWidget, DataSource, DataSourceType, DiagramPropertyMapping, EncodedDescription, EntityAssociation, EntityAttribute, EntityCardConfigResult, EntityCardWidgetConfig, EntityListWidget, EntitySelectorAttributeMapping, EntitySelectorChildScope, EntitySelectorClearEvent, EntitySelectorConfig, EntitySelectorEvent, EntitySelectorScopeState, EntityWidget, EntityWithAssociationsWidgetConfig, FailedExecutionsAttentionOptions, GaugeConfigResult, GaugeRange, GaugeType, GaugeWidgetConfig, GridCell, GridPosition, GroupChildWidgetType, GroupedDataItem, HeatmapAggregation, HeatmapColorMode, HeatmapColorScheme, HeatmapConfigResult, HeatmapWidgetConfig, HourlyExecutionBucket, HourlyHistogramOptions, KpiConfigResult, KpiDataSourceType, KpiQueryMode, KpiValueMode, KpiWidgetConfig, LatestExecutionInput, LineChartConfigResult, LineChartType, LineChartWidgetConfig, MarkdownConfigResult, MarkdownTextAlign, MarkdownWidgetConfig, MeshBoardChrome, MeshBoardConfig, MeshBoardHeaderMode, MeshBoardLabelKind, MeshBoardLabelRequest, MeshBoardLabelResolver, MeshBoardMessages, MeshBoardMessagesSource, MeshBoardNavigationConfig, MeshBoardOptions, MeshBoardTimeFilterConfig, MeshBoardTimeZoneMode, MeshBoardVariable, MeshBoardVariableSource, MeshBoardVariableType, ParentAssociationMode, PersistedDashboard, PersistedMeshBoard, PersistedWidget, PersistedWidgetData, PersistentQueryCellMode, PersistentQueryCellSource, PersistentQueryDataSource, PersistentQueryItem, PieChartConfigResult, PieChartLabelPosition, PieChartType, PieChartWidgetConfig, PipelineExecutionCounts, PipelineExecutionInput, PipelineExecutionsWidgetConfig, PipelineStatisticsInput, ProcessWidgetConfig, Quarter, QueryCell, QueryClassification, QueryColumn, QueryColumnInfo, QueryColumnItem, QueryExecutionOptions, QueryExecutionResult, QueryFamily, QueryKind, QueryResultRow, RawHourBucket, RecentItemsConfigResult, RecentItemsWidgetConfig, RelativeTimeUnit, RepeaterDataItem, RepeaterQueryDataSource, RuntimeEntityData, RuntimeEntityDataSource, RuntimeEntitySelectorValue, SeriesAggregationFunction, SeriesResolutionResult, ServiceCallDataSource, ServiceCallType, ServiceHealthConfigResult, ServiceHealthWidgetConfig, ServicesHealthWidgetConfig, SparklineGeometry, StatColor, StatItem, StaticDataSource, StatsGridConfigResult, StatsGridWidgetConfig, StatusIndicatorConfigResult, StatusIndicatorWidgetConfig, StatusListConfigResult, StatusListWidgetConfig, StreamDataExecutionArgs, StreamDataScope, SummaryCardConfigResult, SummaryCardTile, SummaryCardWidgetConfig, TableColumn, TableColumnStatusIconMapping, TableConfigResult, TableFilterConfig, TableSortConfig, TableWidgetConfig, TargetEntityWithAttributes, TenantCountWidgetConfig, TimeRangePickerConfig, TimeRangeSelection, TimeRangeType, UpdateDashboardResult, VariableResolutionError, VersionInfoWidgetConfig, WidgetConfig, WidgetConfigDialog, WidgetConfigDialogSize, WidgetConfigResult, WidgetCreationOptions, WidgetDataSource, WidgetFilterConfig, WidgetGroupAttributeMappings, WidgetGroupChildTemplate, WidgetGroupConfig, WidgetGroupConfigResult, WidgetGroupLayout, WidgetPersistenceData, WidgetPositionUpdate, WidgetRegistration, WidgetType, WidgetZone };
+export { ADAPTER_OFFLINE_GRACE_MS, ASSOCIATION_HOP_SOURCE_BATCH, ASSOCIATION_HOP_TARGETS_PER_SOURCE, ATTENTION_SEVERITY_ORDER, AdaptersAttentionProvider, AddWidgetDialogComponent, AiInsightsConfigDialogComponent, AiInsightsService, AiInsightsWidgetComponent, AlertBannerConfigDialogComponent, AlertBannerWidgetComponent, AlertListConfigDialogComponent, AlertListWidgetComponent, AssociationsConfigDialogComponent, AttentionListConfigDialogComponent, AttentionListWidgetComponent, AutoRefreshTimerService, BUILT_IN_ATTENTION_PROVIDERS, BarChartConfigDialogComponent, BarChartWidgetComponent, BlueprintUpdatesAttentionProvider, COCKPIT_ADAPTER_LIMIT, COCKPIT_ATTENTION_PROVIDERS, COCKPIT_BLUEPRINT_CATALOG_LIMIT, COCKPIT_CHILD_TENANT_IDS, COCKPIT_DATA_FLOW_LIMIT, COCKPIT_EXPLAIN_HANDLER, COCKPIT_FAILED_EXECUTIONS_OPTIONS, COCKPIT_KPI_GATES, COCKPIT_KPI_SLOW_LOADING_MS, COCKPIT_LINK_RESOLVER, COCKPIT_RECENT_ITEMS, COCKPIT_ROLES, COCKPIT_SERVICE_NAMES, COCKPIT_VERSION_SOURCE, COCKPIT_VIEWER_ACCESS, COCKPIT_WIDGET_MESSAGES, COCKPIT_WIDGET_TYPES, CkModelsResolveFailedAttentionProvider, CockpitAdapterStatesService, CockpitAttentionService, CockpitBlueprintStatusService, CockpitChildTenantsService, CockpitCkModelStatesService, CockpitContextService, CockpitDataFlowExecutionsService, CockpitKpiConfigDialogComponent, CockpitKpiService, CockpitKpiWidgetComponent, CockpitServiceHealthService, DAY_MS, DEFAULT_ATTENTION_MAX_ITEMS, DEFAULT_COCKPIT_WIDGET_MESSAGES, DEFAULT_FAILED_EXECUTIONS_OPTIONS, DEFAULT_MESHBOARD_MESSAGES, DEFAULT_RECENT_ITEMS_MAX, DEFAULT_TIME_ZONE_MODE, DashboardDataService, DashboardGridService, EditModeStateService, EditWidgetDialogComponent, EntityAssociationsWidgetComponent, EntityCardConfigDialogComponent, EntityCardWidgetComponent, EntityDetailDialogComponent, EntitySelectorEditorComponent, EntitySelectorScopePathEditorComponent, EntitySelectorToolbarComponent, FALLBACK_SERIES_COLORS, FailedExecutionsAttentionProvider, FeaturesNotInstalledAttentionProvider, FormulaFieldComponent, GaugeConfigDialogComponent, GaugeWidgetComponent, HISTOGRAM_HOURS, HOUR_MS, HeatmapConfigDialogComponent, HeatmapWidgetComponent, KPI_ERROR_TEXT, KpiConfigDialogComponent, KpiWidgetComponent, LazyMarkdownComponent, LineChartConfigDialogComponent, LineChartWidgetComponent, MAX_RECENT_ITEMS, MAX_SCOPE_HOPS, MESHBOARD_CHROME_ROUTE_DATA, MESHBOARD_DESCRIPTION_MARKER, MESHBOARD_EDIT_QUERY_PARAM, MESHBOARD_HEADER_MODE_ROUTE_DATA, MESHBOARD_LABEL_RESOLVER, MESHBOARD_LANGUAGE, MESHBOARD_MESSAGES, MESHBOARD_OPTIONS, MESHBOARD_TENANT_ID_PROVIDER, MarkdownConfigDialogComponent, MarkdownWidgetComponent, MeshBoardDataService, MeshBoardGridService, MeshBoardManagerDialogComponent, MeshBoardPersistenceService, MeshBoardSettingsDialogComponent, MeshBoardSettingsResult, MeshBoardStateService, MeshBoardViewComponent, NOT_AVAILABLE_TEXT, PieChartConfigDialogComponent, PieChartWidgetComponent, QueryExecutorService, QuerySelectorComponent, RecentItemsConfigDialogComponent, RecentItemsWidgetComponent, RuntimeEntitySelectorComponent, SERVICE_MANAGED_BLUEPRINT_PREFIX, STATE_STATUS_BY_KEY, ServiceHealthConfigDialogComponent, ServiceHealthWidgetComponent, ServicesHealthAttentionProvider, StatsGridConfigDialogComponent, StatsGridWidgetComponent, StatusIndicatorConfigDialogComponent, StatusIndicatorWidgetComponent, StatusListConfigDialogComponent, StatusListWidgetComponent, SummaryCardConfigDialogComponent, SummaryCardWidgetComponent, TableConfigDialogComponent, TableWidgetComponent, TableWidgetDataSourceDirective, UnregisteredPoolsAttentionProvider, WidgetFactoryService, WidgetGroupComponent, WidgetGroupConfigDialogComponent, WidgetNotConfiguredComponent, WidgetRegistryService, adapterKpi, adaptersInError, adaptersOffline, blueprintUpdatesKpi, buildHourlyHistogram, categoryStatus, chartSeriesColors, ckModelKpi, classifyQuery, compareBlueprintVersions, compareMeshBoardNavigation, countFlowExecutions, countLabel, countPipelineExecutions, emptyQueryExecutionResult, enabledButNotInstalled, executionKpi, failedExecutionsSeverity, formatCockpitMessage, formatCount, humanizeCategory, isAdapterAtRest, isAdapterExpectedToRun, isAdapterOnline, isCockpitWidgetType, isMeshBoardChrome, isMeshBoardHeaderMode, isServiceConfigured, joinEncodedDescription, kpiKindOf, latestStatisticsUpdate, legacyCockpitLinkTarget, loadNgxMarkdown, nameList, newMeshBoardConfig, normalizeNavigation, observeThemeChanges, parseHostTimeRange, pickLocalizedText, pipelineExecutionInputs, plural, provideCockpitWidgetHost, provideCockpitWidgets, provideDefaultWidgets, provideMeshBoard, provideMeshBoardLanguage, provideMeshBoardMessages, provideProcessWidget, provideWidgetRegistrations, queryFamily, readMeshBoardNavigation, recentRelativeTime, registerCockpitWidgets, registerDefaultWidgets, registerProcessWidget, resolveChartColor, resolveCockpitWidgetMessages, resolveMeshBoardChrome, resolveMeshBoardHeaderMode, resolveMeshBoardLabel, resolveMeshBoardMessages, selectProviders, serviceStateText, servicesHealthKpi, sortAttentionFindings, sparklineGeometry, splitBlueprintId, splitEncodedDescription, statusColor, summarizeAdapterOnline, tenantCountKpi, toBlueprintStatus, toServiceHealthStatus, truncationNote, versionKpi, withMeshBoardNavigation };
+export type { AdapterOnlineFields, AdapterOnlineSummary, AdapterStatusWidgetConfig, AggregationDataSource, AggregationQuery, AggregationType, AiInsightsConfigResult, AiInsightsWidgetConfig, AlertBannerConfigResult, AlertBannerWidgetConfig, AlertListConfigResult, AlertListWidgetConfig, AnyWidgetConfig, AssociationsConfigResult, AttentionContext, AttentionFinding, AttentionLink, AttentionListConfigResult, AttentionListWidgetConfig, AttentionProvider, AttentionProviderInfo, AttentionSeverity, AttentionState, BarChartColorThreshold, BarChartConfigResult, BarChartSeries, BarChartType, BarChartWidgetConfig, BaseWidgetConfig, BlueprintUpdatesWidgetConfig, CategoryStatus, CategoryValueItem, ChartReferenceLine, CkModelStateWidgetConfig, CkQueryResult, CkQueryTarget, CkTypeAttributeInfo, CockpitAdapterState, CockpitAdapterStates, CockpitBlueprintStatus, CockpitBlueprintUpdate, CockpitChildTenants, CockpitCkModelCounts, CockpitDataFlowExecutions, CockpitDataFlowRow, CockpitExecutionCounts, CockpitExplainHandler, CockpitExplainTarget, CockpitKpi, CockpitKpiConfigResult, CockpitKpiKind, CockpitKpiResult, CockpitKpiStatus, CockpitKpiWidgetConfig, CockpitKpiWidgetOptions, CockpitLinkQueryParams, CockpitLinkResolver, CockpitLinkTarget, CockpitRecentItem, CockpitRecentItemKind, CockpitRecentItemsSource, CockpitResolvedLink, CockpitRouteLinkTarget, CockpitServiceHealth, CockpitServiceHealthStatus, CockpitServiceKey, CockpitVersionEntry, CockpitVersionSource, CockpitViewerAccess, CockpitWidgetHost, CockpitWidgetMessages, CockpitWidgetMessagesSource, CockpitWidgetType, ConfigDialogResult, ConfigResultApplier, ConstructionKitQueryDataSource, DashboardConfig, DashboardWidget, DataSource, DataSourceType, DiagramPropertyMapping, EncodedDescription, EntityAssociation, EntityAttribute, EntityCardConfigResult, EntityCardWidgetConfig, EntityListWidget, EntitySelectorAttributeMapping, EntitySelectorChildScope, EntitySelectorClearEvent, EntitySelectorConfig, EntitySelectorEvent, EntitySelectorScopeHop, EntitySelectorScopeSource, EntitySelectorScopeState, EntityWidget, EntityWithAssociationsWidgetConfig, FailedExecutionsAttentionOptions, GaugeConfigResult, GaugeRange, GaugeType, GaugeWidgetConfig, GridCell, GridPosition, GroupChildWidgetType, GroupedDataItem, HeatmapAggregation, HeatmapColorMode, HeatmapColorScheme, HeatmapConfigResult, HeatmapTimeWindow, HeatmapWidgetConfig, HostTimeRangeState, HourlyExecutionBucket, HourlyHistogramOptions, KpiConfigResult, KpiDataSourceType, KpiQueryMode, KpiValueMode, KpiWidgetConfig, LatestExecutionInput, LineChartConfigResult, LineChartType, LineChartWidgetConfig, MarkdownConfigResult, MarkdownTextAlign, MarkdownWidgetConfig, MeshBoardChrome, MeshBoardConfig, MeshBoardHeaderMode, MeshBoardHostTimeRange, MeshBoardLabelKind, MeshBoardLabelRequest, MeshBoardLabelResolver, MeshBoardLanguageSource, MeshBoardMessages, MeshBoardMessagesSource, MeshBoardNavigationConfig, MeshBoardOptions, MeshBoardTimeFilterConfig, MeshBoardTimeFilterControl, MeshBoardTimeZoneMode, MeshBoardVariable, MeshBoardVariableSource, MeshBoardVariableType, ParentAssociationMode, PersistedDashboard, PersistedMeshBoard, PersistedWidget, PersistedWidgetData, PersistentQueryCellMode, PersistentQueryCellSource, PersistentQueryDataSource, PersistentQueryItem, PieChartConfigResult, PieChartLabelPosition, PieChartType, PieChartWidgetConfig, PipelineExecutionCounts, PipelineExecutionInput, PipelineExecutionsWidgetConfig, PipelineStatisticsInput, ProcessWidgetConfig, Quarter, QueryCell, QueryClassification, QueryColumn, QueryColumnInfo, QueryColumnItem, QueryExecutionOptions, QueryExecutionResult, QueryFamily, QueryKind, QueryResultRow, RawHourBucket, RecentItemsConfigResult, RecentItemsWidgetConfig, RelativeTimeUnit, RepeaterDataItem, RepeaterQueryDataSource, RuntimeEntityData, RuntimeEntityDataSource, RuntimeEntitySelectorValue, SeriesAggregationFunction, SeriesResolutionResult, ServiceCallDataSource, ServiceCallType, ServiceHealthConfigResult, ServiceHealthWidgetConfig, ServicesHealthWidgetConfig, SparklineGeometry, StatColor, StatItem, StaticDataSource, StatsGridConfigResult, StatsGridWidgetConfig, StatusIndicatorConfigResult, StatusIndicatorWidgetConfig, StatusListConfigResult, StatusListWidgetConfig, StreamDataExecutionArgs, StreamDataScope, SummaryCardConfigResult, SummaryCardTile, SummaryCardWidgetConfig, TableColumn, TableColumnStatusIconMapping, TableColumnValueLabel, TableConfigResult, TableFilterConfig, TableSortConfig, TableWidgetConfig, TargetEntityWithAttributes, TenantCountWidgetConfig, TimeRangePickerConfig, TimeRangeSelection, TimeRangeType, UpdateDashboardResult, VariableResolutionError, VersionInfoWidgetConfig, WidgetConfig, WidgetConfigDialog, WidgetConfigDialogSize, WidgetConfigResult, WidgetCreationOptions, WidgetDataSource, WidgetFilterConfig, WidgetGroupAttributeMappings, WidgetGroupChildTemplate, WidgetGroupConfig, WidgetGroupConfigResult, WidgetGroupLayout, WidgetPersistenceData, WidgetPositionUpdate, WidgetRegistration, WidgetType, WidgetZone };