@meshmakers/octo-meshboard 3.4.1480 → 3.5.0

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

@@ -1,19 +1,20 @@
 import { ProcessWidgetSpecificConfig } from '@meshmakers/octo-process-diagrams';
 import * as _angular_core from '@angular/core';
-import { Signal, AfterViewInit, OnChanges, EventEmitter, SimpleChanges, Type, OnDestroy, OnInit, EnvironmentProviders, InjectionToken } from '@angular/core';
+import { Signal, AfterViewInit, OnChanges, EventEmitter, SimpleChanges, Type, OnDestroy, OnInit, EnvironmentProviders, InjectionToken, Provider } from '@angular/core';
 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, HasUnsavedChanges, TimeRangePickerLabels, TimeRangeSelection as TimeRangeSelection$1 } 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 { Observable, Subject } from 'rxjs';
 import { EntitySelectDataSource, EntitySelectResult } from '@meshmakers/shared-services';
 import * as Types from '@meshmakers/octo-services';
-import { CkTypeSelectorItem, RuntimeEntityItem, RuntimeEntitySelectDataSource, RuntimeEntityDialogDataSource, SortDto, FieldFilterDto, QueryModeDto, ResolveSeriesQueryInputDto, CkRollupFunctionDto, SeriesResolutionSignalDto, AttributeItem, TenantIdProvider } from '@meshmakers/octo-services';
+import { CkTypeSelectorItem, RuntimeEntityItem, RuntimeEntitySelectDataSource, RuntimeEntityDialogDataSource, SortDto, FieldFilterDto, QueryModeDto, ResolveSeriesQueryInputDto, CkRollupFunctionDto, SeriesResolutionSignalDto, AttributeItem, TenantIdProvider, TenantFeaturesStatus, HealthCheck } from '@meshmakers/octo-services';
 export { RuntimeEntityDialogDataSource, RuntimeEntityItem, RuntimeEntitySelectDataSource, TENANT_ID_PROVIDER, TenantIdProvider } from '@meshmakers/octo-services';
 import * as Apollo from 'apollo-angular';
 import { CkTypeSelectorInputComponent, AttributeValueTypeDto, FieldFilterItem, FilterVariable, PropertyGridItem, PropertyGridConfig, OctoGraphQlDataSource, FieldFilterEditorComponent } from '@meshmakers/octo-ui';
 import * as _meshmakers_octo_meshboard from '@meshmakers/octo-meshboard';
 import * as _progress_kendo_svg_icons from '@progress/kendo-svg-icons';
 import { SVGIcon } from '@progress/kendo-svg-icons';
+import * as ngx_markdown from 'ngx-markdown';
 import { TileLayoutReorderEvent, TileLayoutResizeEvent } from '@progress/kendo-angular-layout';
 
 /**
@@ -417,7 +418,7 @@ type DataSource = RuntimeEntityDataSource | StaticDataSource | PersistentQueryDa
 /**
  * Supported widget types
  */
-type WidgetType = 'entityCard' | 'entityWithAssociations' | 'kpi' | 'table' | 'gauge' | 'pieChart' | 'barChart' | 'lineChart' | 'heatmap' | 'statsGrid' | 'statusIndicator' | 'serviceHealth' | 'process' | 'widgetGroup' | 'markdown' | 'statusList' | 'summaryCard' | 'alertBanner' | 'alertList' | 'aiInsights';
+type WidgetType = 'entityCard' | 'entityWithAssociations' | 'kpi' | 'table' | 'gauge' | 'pieChart' | 'barChart' | 'lineChart' | 'heatmap' | 'statsGrid' | 'statusIndicator' | 'serviceHealth' | 'process' | 'widgetGroup' | 'markdown' | 'statusList' | 'summaryCard' | 'alertBanner' | 'alertList' | 'aiInsights' | CockpitWidgetType | 'recentItems';
 /**
  * Widget placement zone.
  * - 'grid': Rendered inside the Kendo TileLayout grid (default)
@@ -579,6 +580,12 @@ interface TableColumn {
     title: string;
     width?: number;
     dataType?: string;
+    /**
+     * Display format passed to the list view. For `dataType: 'numeric'` it is an Angular
+     * DecimalPipe digits info, e.g. `'1.2-2'` for exactly two decimals; without it the
+     * pipe's default (up to three decimals) applies.
+     */
+    format?: string;
     statusMapping?: Record<string, TableColumnStatusIconMapping>;
 }
 /**
@@ -655,7 +662,26 @@ interface PieChartWidgetConfig extends WidgetConfig {
     legendPosition?: 'top' | 'bottom' | 'left' | 'right';
     /** Field filters for data source */
     filters?: WidgetFilterConfig[];
+    /**
+     * Colour per category (AB#5622), keyed by the raw category value (`PAID`; case-insensitive) or
+     * its displayed label. Value: a hex / CSS colour, a custom property (`--brand-paid`,
+     * `var(--brand-paid, #2fb37a)`) or a status name (`success`, `warning`, `error`, `info`).
+     * Categories without an entry keep the default (status colour, else the theme palette).
+     */
+    categoryColors?: Record<string, string>;
+    /**
+     * Where slice labels sit while `showLabels` is on (AB#5622): `outside` (with connector lines),
+     * `inside` or `none` (no labels). Absent = the chart default (outside, unchanged).
+     */
+    labelPosition?: PieChartLabelPosition;
+    /**
+     * Overlap handling (AB#5622): slices smaller than this share of the total (in percent, e.g. `3`)
+     * get no label, so small neighbours do not overlap. Absent / 0 = every slice is labelled.
+     */
+    hideLabelsBelowPercent?: number;
 }
+/** Slice label position of a pie / donut chart (AB#5622). */
+type PieChartLabelPosition = 'inside' | 'outside' | 'none';
 /**
  * Bar Chart types available
  * - column: Vertical bars (standard column chart)
@@ -1136,8 +1162,82 @@ interface AiInsightsWidgetConfig extends WidgetConfig {
     /** Domain context hint (default: energy management) */
     domainContext?: string;
 }
+/**
+ * Platform health widgets, formerly hard-wired on the Refinery Studio's Home cockpit (AB#5545).
+ * They read fixed platform data (adapters, pools, CK models, data flows, tenant features) instead
+ * of a configurable data source, gate every check on the viewer's roles and the tenant's CK models
+ * (`COCKPIT_VIEWER_ACCESS`) and are registered with `provideCockpitWidgets()`.
+ */
+type CockpitWidgetType = 'attentionList' | 'adapterStatus' | 'ckModelState' | 'pipelineExecutions' | 'tenantCount' | 'blueprintUpdates' | 'servicesHealth' | 'versionInfo';
+/** The cockpit widget types (e.g. to tell whether a board already shows them). */
+declare const COCKPIT_WIDGET_TYPES: readonly CockpitWidgetType[];
+/** True for the cockpit widget types. */
+declare function isCockpitWidgetType(type: string | null | undefined): type is CockpitWidgetType;
+/**
+ * "Attention list" — rule-based health findings (ResolveFailed CK models, unregistered pools,
+ * features enabled but not installed, adapters in error / offline, host-provided checks such as
+ * secrets needing re-entry). Each provider runs only when the viewer may open what it links to.
+ */
+interface AttentionListWidgetConfig extends WidgetConfig {
+    type: 'attentionList';
+    /** Provider ids to run (`AttentionProvider.id`); empty / undefined = every registered provider. */
+    providerIds?: string[];
+    /** Findings shown before "and N more" (default 6). */
+    maxItems?: number;
+    /** Show "✦ Explain" on findings when the host's assistant is enabled (default true). */
+    showExplain?: boolean;
+}
+/** Display options shared by the cockpit KPI widgets. */
+interface CockpitKpiWidgetOptions {
+    /** Show the secondary line under the value (default true). */
+    showDetail?: boolean;
+}
+/** "Adapter status" — adapters online of those expected to run (the shared adapter online rule). */
+interface AdapterStatusWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'adapterStatus';
+}
+/** "CK model state" — CK models available of all, ResolveFailed as error, importing as progress. */
+interface CkModelStateWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'ckModelState';
+}
+/** "Pipeline executions 24 h" — executions of all data flows with failed count and hourly sparkline. */
+interface PipelineExecutionsWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'pipelineExecutions';
+    /** Show the hourly sparkline (default true). */
+    showSparkline?: boolean;
+}
+/** "Tenants" (system cockpit, AB#5558) — child tenants of the current tenant. */
+interface TenantCountWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'tenantCount';
+}
+/** "Blueprint updates" (system cockpit, AB#5558) — installed blueprints with a newer catalog version. */
+interface BlueprintUpdatesWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'blueprintUpdates';
+}
+/** "Services healthy" (system cockpit, AB#5558) — platform services whose health check is Healthy. */
+interface ServicesHealthWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'servicesHealth';
+}
+/** "Version" (system cockpit, AB#5558) — the host application's versions (`COCKPIT_VERSION_SOURCE`). */
+interface VersionInfoWidgetConfig extends WidgetConfig, CockpitKpiWidgetOptions {
+    type: 'versionInfo';
+}
+/** Any cockpit KPI widget. */
+type CockpitKpiWidgetConfig = AdapterStatusWidgetConfig | CkModelStateWidgetConfig | PipelineExecutionsWidgetConfig | TenantCountWidgetConfig | BlueprintUpdatesWidgetConfig | ServicesHealthWidgetConfig | VersionInfoWidgetConfig;
+/**
+ * "Recent items" (AB#5558) — the viewer's recently opened pages, entities and boards, from the
+ * host's `COCKPIT_RECENT_ITEMS` source (in the Refinery Studio the same history as the empty
+ * Cmd+K palette). Per user, so the board only stores how many rows to show. Registered by
+ * `provideCockpitWidgets()`, but deliberately NOT a {@link CockpitWidgetType}: it is no health
+ * widget, so a board that only shows recents still gets a host's health fallbacks.
+ */
+interface RecentItemsWidgetConfig extends WidgetConfig {
+    type: 'recentItems';
+    /** Rows shown (default 8, 1–20). */
+    maxItems?: number;
+}
 
-type AnyWidgetConfig = EntityCardWidgetConfig | EntityWithAssociationsWidgetConfig | KpiWidgetConfig | TableWidgetConfig | GaugeWidgetConfig | PieChartWidgetConfig | BarChartWidgetConfig | LineChartWidgetConfig | HeatmapWidgetConfig | StatsGridWidgetConfig | StatusIndicatorWidgetConfig | ServiceHealthWidgetConfig | ProcessWidgetConfig | WidgetGroupConfig | MarkdownWidgetConfig | StatusListWidgetConfig | SummaryCardWidgetConfig | AlertBannerWidgetConfig | AlertListWidgetConfig | AiInsightsWidgetConfig;
+type AnyWidgetConfig = EntityCardWidgetConfig | EntityWithAssociationsWidgetConfig | KpiWidgetConfig | TableWidgetConfig | GaugeWidgetConfig | PieChartWidgetConfig | BarChartWidgetConfig | LineChartWidgetConfig | HeatmapWidgetConfig | StatsGridWidgetConfig | StatusIndicatorWidgetConfig | ServiceHealthWidgetConfig | ProcessWidgetConfig | WidgetGroupConfig | MarkdownWidgetConfig | StatusListWidgetConfig | SummaryCardWidgetConfig | AlertBannerWidgetConfig | AlertListWidgetConfig | AiInsightsWidgetConfig | AttentionListWidgetConfig | AdapterStatusWidgetConfig | CkModelStateWidgetConfig | PipelineExecutionsWidgetConfig | TenantCountWidgetConfig | BlueprintUpdatesWidgetConfig | ServicesHealthWidgetConfig | VersionInfoWidgetConfig | RecentItemsWidgetConfig;
 /**
  * Supported variable types
  */
@@ -1352,8 +1452,24 @@ interface MeshBoardConfig {
      * tab is hidden. Stream-data and runtime widgets refresh identically.
      */
     autoRefreshSeconds?: number;
+    /**
+     * Host-app navigation settings. A pinned board is listed in the host's
+     * end-user (Home) navigation; `undefined` means not pinned. Stored
+     * in the encoded description blob like the other settings above.
+     */
+    navigation?: MeshBoardNavigationConfig;
     widgets: AnyWidgetConfig[];
 }
+/**
+ * Navigation settings of a MeshBoard in the host application.
+ * Only `pinned: true` is ever persisted; an unpinned board stores nothing.
+ */
+interface MeshBoardNavigationConfig {
+    /** Shown in the host app's end-user navigation. */
+    pinned: boolean;
+    /** Sort position among pinned boards (ascending). Boards without one sort last, by name. */
+    order?: number;
+}
 /** @deprecated Use MeshBoardConfig instead */
 type DashboardConfig = MeshBoardConfig;
 interface EntityAttribute {
@@ -1460,6 +1576,188 @@ interface CategoryValueItem {
     displayValue: string;
 }
 
+/**
+ * Marker that separates the human-readable MeshBoard description from the
+ * JSON blob the MeshBoard persists alongside it (variables, time filter,
+ * entity selectors, auto-refresh, navigation).
+ *
+ * Format: `<description>\n---MESHBOARD_VARIABLES---\n<json>`
+ *
+ * This is a stop-gap until System.UI/Dashboard gets a first-class config
+ * attribute. The backend may trim leading/trailing whitespace, so the marker
+ * can sit at the very start of the stored string when the description is empty.
+ */
+declare const MESHBOARD_DESCRIPTION_MARKER = "---MESHBOARD_VARIABLES---";
+/** A stored description split into its two halves. */
+interface EncodedDescription {
+    /** The part a person wrote, without the marker and without trailing newlines. */
+    description: string;
+    /**
+     * The parsed JSON blob, or `null` when the stored string carries no marker
+     * (or the JSON after it is unreadable). A legacy blob that was a bare
+     * variables array is normalised to `{ variables: [...] }`.
+     */
+    data: Record<string, unknown> | null;
+}
+/**
+ * Splits a stored description into the human-readable text and the encoded
+ * JSON data. Never throws: unreadable JSON yields `data: null` and the text
+ * before the marker is still returned.
+ */
+declare function splitEncodedDescription(raw: string | null | undefined): EncodedDescription;
+/**
+ * Joins a description and its data blob back into the stored form. An empty
+ * or `null` blob yields the bare description, so a board without any encoded
+ * settings never carries a dangling marker.
+ */
+declare function joinEncodedDescription(description: string, data: Record<string, unknown> | null): string;
+/**
+ * Reads the navigation settings of a MeshBoard from its stored description.
+ * Returns `undefined` when the board carries none (= not pinned).
+ */
+declare function readMeshBoardNavigation(raw: string | null | undefined): MeshBoardNavigationConfig | undefined;
+/**
+ * Returns the stored description with the navigation settings replaced.
+ * Passing `undefined` (or `{ pinned: false }`) removes the entry so unpinned
+ * boards store nothing. Every other encoded setting is preserved verbatim.
+ */
+declare function withMeshBoardNavigation(raw: string | null | undefined, navigation: MeshBoardNavigationConfig | undefined): string;
+/**
+ * Validates an untyped navigation entry. Only a pinned board is worth storing,
+ * so anything that is not `{ pinned: true }` collapses to `undefined`.
+ */
+declare function normalizeNavigation(value: unknown): MeshBoardNavigationConfig | undefined;
+/**
+ * Sort comparator for pinned boards: explicit `order` first (ascending),
+ * boards without an order afterwards, ties broken by name.
+ */
+declare function compareMeshBoardNavigation(a: {
+    name: string;
+    navigation?: MeshBoardNavigationConfig;
+}, b: {
+    name: string;
+    navigation?: MeshBoardNavigationConfig;
+}): number;
+
+/**
+ * Category helpers of the MeshBoard charts (visual check #15 of the Studio rebuild): enum-style
+ * categories such as `RESOLVE_FAILED` read as "Resolve failed", well-known state categories get
+ * status colours (a failed state must never be drawn in the success/accent colour), and a legend
+ * beside a narrow chart moves below it so the plot keeps its size.
+ */
+/** `RESOLVE_FAILED` / `ResolveFailed` → `Resolve failed`; other text is returned unchanged. */
+declare function humanizeCategory(category: string): string;
+type CategoryStatus = 'success' | 'warning' | 'error' | 'info';
+/**
+ * THE status table of well-known state names (CK enum option names, query categories), keys
+ * normalised (lower case, no separators). Shared by the MeshBoard charts and the Refinery Studio
+ * Data Explorer enum chips, so a state reads the same everywhere.
+ */
+declare const STATE_STATUS_BY_KEY: Readonly<Record<string, CategoryStatus>>;
+/** Status of a well-known state category (case and separators ignored), else null. */
+declare function categoryStatus(category: string): CategoryStatus | null;
+/**
+ * The theme colour of a status for an SVG chart. Charts need a concrete colour, so the host's
+ * `--theme-status-<status>` (Studio Deep Sea tokens), then `--kendo-color-<status>` are read from
+ * the document; a fixed colour is the last resort (and the value in environments without CSS).
+ */
+declare function statusColor(status: CategoryStatus, doc?: Document | null): string;
+/**
+ * Text and line colours of a Kendo chart (AB#5568). Kendo reads its chart theme from the DOM once
+ * per page load, so legend, axis and data labels keep the colours of the theme the page was loaded
+ * with; the widgets therefore pass these resolved tokens explicitly.
+ */
+interface ChartThemeColors {
+    /** Legend and data labels. */
+    text: string;
+    /** Axis labels and axis titles. */
+    muted: string;
+    /** Major grid lines. */
+    grid: string;
+}
+/** Fixed series colours, the last resort when the host theme defines no chart palette (or no CSS). */
+declare const FALLBACK_SERIES_COLORS: readonly string[];
+/**
+ * The categorical chart palette of the current theme (AB#5622): the host's `--theme-chart-1…12`
+ * (Studio tokens), else the Kendo theme's `--kendo-chart-series-1…12`, else
+ * `--kendo-color-series-a…f`, else {@link FALLBACK_SERIES_COLORS}. Values that are empty, still
+ * contain `var()` or are no valid colour are skipped — Kendo resolves its series colours once per
+ * page load, and a token it could not resolve rendered a slice black in dark mode. The charts set
+ * these colours explicitly on every data item, so the palette also follows a live theme switch.
+ */
+declare function chartSeriesColors(doc?: Document | null): string[];
+/**
+ * Resolves a configured colour (per-category colour of a chart, AB#5622): a status name
+ * (`success`, `warning`, `error`, `info` → theme status colour), a custom property (`--brand-paid`
+ * or `var(--brand-paid, #2fb37a)`) read from the document root, or any CSS colour (`#2fb37a`,
+ * `rgb(…)`) used as it is. Returns `undefined` when it cannot be resolved (the default colour applies).
+ */
+declare function resolveChartColor(token: string | null | undefined, doc?: Document | null): string | undefined;
+/**
+ * Calls `onChange` when the colour theme really changed: `<html>` `data-theme`, `class` or
+ * `style` mutated (the Studio ThemeService sets `data-theme`) or the OS colour scheme switched,
+ * **and** the theme signature (`themeSignature`) differs from the last one. Hovering a chart
+ * opens tooltips / popups that mutate `<html>`; reacting to every mutation made the pie redraw
+ * endlessly (AB#5568). Returns the unsubscribe.
+ */
+declare function observeThemeChanges(onChange: () => void, doc?: Document | null): () => void;
+
+/**
+ * `?edit=1` on a MeshBoard URL opens the board in edit mode once it has loaded (e.g. "Edit" in a
+ * host's board list). Pure helpers so the rule is unit-testable without the view.
+ */
+/** Query parameter that requests edit mode. */
+declare const MESHBOARD_EDIT_QUERY_PARAM = "edit";
+
+/**
+ * How much of its header a MeshBoard view shows (AB#5558). The header is a property of the
+ * host page, not of the board: the same board is shown with its name in UI › MeshBoards and
+ * without it on a host page that already names it (e.g. a Home tab under a greeting).
+ *
+ * - `full` (default): board name, description and the board controls.
+ * - `compact`: no name and no description; the controls (time filter, entity selectors,
+ *   refresh, and for editable boards manager / settings / edit / add / save) stay in a slim
+ *   row aligned right.
+ * - `none`: no header row at all — for hosts that offer their own controls. Hints (unselected
+ *   entity selectors, variable errors) and the "not found" / "not available" help still show.
+ *
+ * Pure helpers so the rule is unit-testable without the view.
+ */
+type MeshBoardHeaderMode = 'full' | 'compact' | 'none';
+/** Route data key a route uses when it loads the view directly (no template to bind the input). */
+declare const MESHBOARD_HEADER_MODE_ROUTE_DATA = "meshBoardHeaderMode";
+/** Whether the value is a known header mode. */
+declare function isMeshBoardHeaderMode(value: unknown): value is MeshBoardHeaderMode;
+/**
+ * The effective header mode: the bound input wins over the route data; unknown or missing
+ * values fall back to `full`.
+ */
+declare function resolveMeshBoardHeaderMode(inputMode: unknown, routeDataMode: unknown): MeshBoardHeaderMode;
+
+/**
+ * Whether a MeshBoard view draws its own outer frame (AB#5558). Like the header mode this is a
+ * property of the host page: a standalone board page frames the board, a host page that already
+ * provides the surface and the gutter (e.g. a Home tab) embeds it plain.
+ *
+ * - `framed` (default): the view paints its own background, the header bar (background and
+ *   bottom border) and the grid padding around the widgets.
+ * - `plain`: no outer background, no header bar background or border and no outer padding — the
+ *   widgets sit directly on the host page and align with its gutter. The widget frames (tile
+ *   border, background, shadow) and the gap between the widgets stay unchanged.
+ *
+ * Pure helpers so the rule is unit-testable without the view.
+ */
+type MeshBoardChrome = 'framed' | 'plain';
+/** Route data key a route uses when it loads the view directly (no template to bind the input). */
+declare const MESHBOARD_CHROME_ROUTE_DATA = "meshBoardChrome";
+/** Whether the value is a known chrome. */
+declare function isMeshBoardChrome(value: unknown): value is MeshBoardChrome;
+/**
+ * The effective chrome: the bound input wins over the route data; unknown or missing values
+ * fall back to `framed`.
+ */
+declare function resolveMeshBoardChrome(inputChrome: unknown, routeDataChrome: unknown): MeshBoardChrome;
+
 type GetSystemPersistentQueriesQueryVariablesDto = Types.Exact<{
     after?: Types.InputMaybe<Types.Scalars['String']['input']>;
     first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
@@ -1809,6 +2107,13 @@ declare class MeshBoardPersistenceService {
      * Renames a MeshBoard (updates name and description)
      */
     renameMeshBoard(rtId: string, name: string, description: string): Promise<void>;
+    /**
+     * Pins or unpins a MeshBoard for the host app's end-user navigation.
+     * Only the description is written: the navigation entry lives in the encoded
+     * blob, and every other encoded setting (variables, time filter, …) is kept.
+     * Returns the description as it was stored.
+     */
+    setMeshBoardPinned(meshBoard: PersistedMeshBoard, pinned: boolean): Promise<string>;
     /**
      * Encodes variables and timeFilter into the description field.
      * Format: <description>\n---MESHBOARD_VARIABLES---\n<json>
@@ -1837,6 +2142,7 @@ declare class MeshBoardStateService {
     private readonly ckModelService;
     private readonly persistenceService;
     private readonly gridService;
+    private readonly tenantIdProvider;
     private readonly _meshBoardConfig;
     private readonly _persistedMeshBoardId;
     /** Stores the rtIds of widgets that exist in the backend */
@@ -1858,6 +2164,26 @@ declare class MeshBoardStateService {
      * no dirty state. Cleared on every board switch.
      */
     private readonly _widgetVariables;
+    /**
+     * Widgets that reported "nothing for this viewer" (AB#5558, e.g. a cockpit KPI an end user may not
+     * use). Transient, per board load; the view leaves them out outside edit mode.
+     */
+    private readonly _hiddenForViewer;
+    readonly hiddenForViewer: _angular_core.Signal<ReadonlySet<string>>;
+    /**
+     * Natural content height (px) reported by content-sized widgets (AB#5558: the cockpit attention
+     * and recent-items lists). On the phone tier the view grows their tiles to fit instead of
+     * clipping; other tiers ignore it. Transient, cleared on board switch.
+     */
+    private readonly _widgetContentHeights;
+    readonly widgetContentHeights: _angular_core.Signal<ReadonlyMap<string, number>>;
+    /**
+     * Tenant the loaded board belongs to (from `TENANT_ID_PROVIDER` at load time; `null` when the host
+     * provides none). The service is a singleton across tenant switches, so a host comparing
+     * well-known names (e.g. the Studio's `cockpit`) must also compare this (AB#5558).
+     */
+    private readonly _loadedTenantId;
+    readonly loadedTenantId: _angular_core.Signal<string | null>;
     readonly meshBoardConfig: _angular_core.Signal<MeshBoardConfig>;
     readonly persistedMeshBoardId: _angular_core.Signal<string | null>;
     /** @deprecated Use existingWidgetRtIds instead */
@@ -1993,6 +2319,12 @@ declare class MeshBoardStateService {
     renameMeshBoard(rtId: string, name: string, description: string): Promise<void>;
     /** @deprecated Use renameMeshBoard instead */
     renameDashboard(rtId: string, name: string, description: string): Promise<void>;
+    /**
+     * Pins or unpins the specified MeshBoard for the host app's end-user
+     * navigation and refreshes the list. The active board's config follows, so
+     * a later save does not revert the change.
+     */
+    setMeshBoardPinned(rtId: string, pinned: boolean): Promise<void>;
     /**
      * Duplicates an existing MeshBoard including all its widgets, variables, and time filter settings.
      * Returns the rtId of the newly created MeshBoard.
@@ -2022,6 +2354,18 @@ declare class MeshBoardStateService {
      * nothing when name and value are unchanged, so publishing effects cannot loop.
      */
     setWidgetVariable(widgetId: string, name: string, value: string): void;
+    private currentTenantId;
+    /**
+     * A content-sized widget reports the natural height of its content in px (`null` removes it).
+     * Must be measured on content whose height does not depend on the tile height, or a growing
+     * tile would grow again. Changes below 1 px are ignored.
+     */
+    setWidgetContentHeight(widgetId: string, height: number | null): void;
+    /**
+     * A widget reports that it has nothing for the current viewer (`hidden: true`) or has again.
+     * The view collapses such widgets outside edit mode; the flag is cleared on board switch.
+     */
+    setWidgetHiddenForViewer(widgetId: string, hidden: boolean): void;
     /**
      * Removes the runtime variable published by a widget (e.g. when it is destroyed).
      */
@@ -2163,6 +2507,11 @@ declare class MeshBoardStateService {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeshBoardStateService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeshBoardStateService>;
 }
+/**
+ * Layout defaults of a new, empty MeshBoard (6 columns, 200 px rows, 16 px gap). Shared by
+ * `createNewMeshBoard` and hosts that create boards themselves (e.g. a board list page).
+ */
+declare function newMeshBoardConfig(name: string, description?: string): MeshBoardConfig;
 
 /**
  * Grouped data item for chart visualization
@@ -2216,6 +2565,7 @@ declare class MeshBoardDataService {
     private readonly getEntitiesByCkTypeGQL;
     private readonly queryExecutor;
     private readonly getAssociationTargetsGQL;
+    private readonly secretSafeNames;
     private readonly getCkTypeAttributesGQL;
     private readonly apollo;
     private readonly stateService;
@@ -2232,6 +2582,11 @@ declare class MeshBoardDataService {
      * Fetches a single entity with associations by rtId and ckTypeId (using generic query)
      */
     fetchEntityWithAssociations(rtId: string, ckTypeId: string): Observable<RuntimeEntityData | null>;
+    /**
+     * Loads one entity with all NON-secret attributes of its type (record sub-attributes included;
+     * SECRET-safe, AB#5542 — credentials never reach the dashboard).
+     */
+    private fetchDashboardEntity;
     /**
      * Maps GraphQL entity response to RuntimeEntityData
      */
@@ -2736,8 +3091,10 @@ interface SeriesResolutionResult {
      * Set only on `CoverageLimited`, null otherwise. Passed through as the wire delivers it —
      * a `DateTime` scalar arrives as an ISO string unless a scalar parser turns it into a `Date` —
      * so read it through `toInstant` / `formatInstant` rather than assuming either shape.
+     * Optional so that code constructing a result (mocks, adapters) written before AB#5157 keeps
+     * compiling; a missing value means the same as `null`.
      */
-    finerRungAvailableFrom: Date | string | null;
+    finerRungAvailableFrom?: Date | string | null;
 }
 /**
  * Time-range and downsampling arguments for stream-data persistent queries.
@@ -2845,6 +3202,7 @@ declare class QueryExecutorService {
     private readonly queryArchiveGql;
     private readonly downsampleGql;
     private readonly entitiesGql;
+    private readonly secretSafeNames;
     /**
      * Cache of resolved query families, keyed by query rtId. Filled lazily for
      * legacy widget configs that pre-date the `queryFamily` field — saves a
@@ -2908,6 +3266,12 @@ declare class QueryExecutorService {
      * simply omitted; the caller falls back to the rtId. Returns a `rtId → label` map.
      */
     fetchSeriesLabels(ckTypeId: string, rtIds: string[], labelField: string): Promise<Map<string, string>>;
+    /**
+     * The non-secret attribute names of `ckTypeId` whose canonical form matches `wanted`
+     * (SECRET-safe explicit list, AB#5542). Empty when nothing matches — the caller then falls back
+     * as for a missing attribute.
+     */
+    private matchingAttributeNames;
     /** Cap on the source-entity population read for group-aggregation (AB#4714). A truncated read is
      *  logged, never silent. */
     private static readonly ENTITY_GROUP_FETCH_CAP;
@@ -3540,6 +3904,7 @@ declare class AssociationsConfigDialogComponent implements OnInit {
  */
 declare class EntityDetailDialogComponent implements OnInit {
     private readonly getDashboardEntityGQL;
+    private readonly secretSafeNames;
     rtId: string;
     ckTypeId: string;
     closed: EventEmitter<void>;
@@ -3573,6 +3938,7 @@ interface QueryColumn {
  */
 declare class TableWidgetDataSourceDirective extends OctoGraphQlDataSource<Record<string, unknown>> {
     private readonly getEntitiesByCkTypeGQL;
+    private readonly secretSafeNames;
     private readonly queryExecutor;
     private readonly stateService;
     private readonly variableService;
@@ -3650,6 +4016,12 @@ declare class TableWidgetComponent implements DashboardWidget<TableWidgetConfig,
     config: 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">>>;
+    /** 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;
     private readonly _isLoading;
     private readonly _data;
     private readonly _error;
@@ -3872,6 +4244,7 @@ interface GaugeTypeOption {
  * Allows selecting data source, gauge type, value attribute, and display options.
  */
 declare class GaugeConfigDialogComponent implements OnInit {
+    protected readonly deleteIcon: _progress_kendo_svg_icons.SVGIcon;
     private readonly getEntitiesByCkTypeGQL;
     private readonly ckTypeSelectorService;
     private readonly attributeSelectorService;
@@ -3994,18 +4367,47 @@ declare class GaugeConfigDialogComponent implements OnInit {
 interface ChartDataItem {
     category: string;
     value: number;
+    /**
+     * Slice colour: the configured category colour, else the status colour of a well-known state
+     * category (`RESOLVE_FAILED` → error), else the theme palette colour of its position (AB#5622).
+     */
+    color?: string;
 }
-declare class PieChartWidgetComponent implements DashboardWidget<PieChartWidgetConfig, ChartDataItem[]>, OnInit, OnChanges {
+/** Plot area options of the pie / donut (stable references, AB#5568). */
+interface PieChartPlotArea {
+    background: string;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}
+declare class PieChartWidgetComponent implements DashboardWidget<PieChartWidgetConfig, ChartDataItem[]>, OnInit, OnChanges, AfterViewInit, OnDestroy {
     private readonly queryExecutor;
+    private readonly elementRef;
+    private readonly ngZone;
+    private resizeObserver?;
+    /** Measured widget width (0 until measured). */
+    private readonly width;
     private static readonly SUPPORTED_ROW_TYPES;
     private readonly dataService;
     private readonly stateService;
     private readonly variableService;
+    /** Host translation of category names (`MESHBOARD_LABEL_RESOLVER`, AB#5622): slices, legend and tooltips. */
+    private readonly labelResolver;
     config: PieChartWidgetConfig;
     private readonly _isLoading;
-    private readonly _chartData;
+    /** Raw categories and values as loaded; labels and status colours are derived in `chartData`. */
+    private readonly _rawData;
+    /**
+     * Text colours of the current theme; changes only on a real theme switch, so status colours,
+     * legend and labels are resolved again then (Kendo keeps the load-time theme otherwise).
+     */
+    protected readonly chartTheme: _angular_core.Signal<ChartThemeColors>;
     private readonly _error;
     readonly isLoading: _angular_core.Signal<boolean>;
+    /** Keeps its reference while categories, values and colours are unchanged (AB#5568). */
     readonly chartData: _angular_core.Signal<ChartDataItem[]>;
     readonly error: _angular_core.Signal<string | null>;
     readonly data: _angular_core.Signal<ChartDataItem[]>;
@@ -4014,21 +4416,50 @@ declare class PieChartWidgetComponent implements DashboardWidget<PieChartWidgetC
      * This is a method (not computed) to ensure it re-evaluates when config changes via @Input.
      */
     isNotConfigured(): boolean;
-    /** Extra margin around the plot area so outsideEnd labels are not clipped by the SVG boundary. */
-    readonly plotAreaMargin: {
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    };
+    /**
+     * Plot area: extra margin so outsideEnd labels are not clipped by the SVG boundary — only while
+     * labels are shown; without labels it would shrink the pie for nothing. Returns one of two
+     * constant objects: a new object per change detection made Kendo redraw (and re-animate) the
+     * chart on every hover (AB#5568).
+     */
+    plotArea(): PieChartPlotArea;
+    /** Margin of the plot area (see `plotArea`). */
+    plotAreaMargin(): PieChartPlotArea['margin'];
+    /**
+     * A legend beside a narrow widget (cockpit tiles are ~300 px wide) leaves the pie a dot; it moves
+     * below the chart there. Method, not computed: `config` is a plain @Input.
+     */
+    legendPosition(): 'top' | 'bottom' | 'left' | 'right';
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Human label and status colour for a raw category value (exposed for tests). The label is the
+     * host resolver's text (AB#5622), else the humanized category; the colour still follows the raw value.
+     */
+    toItem(rawCategory: string, value: number, index?: number, palette?: readonly string[]): ChartDataItem;
+    /** The `categoryColors` entry of a category (raw value, case-insensitive, then the label), resolved. */
+    private configuredColor;
+    /** Display name of a raw category: the host label resolver, else `humanizeCategory`. */
+    private categoryLabel;
     private readonly _labelSettings;
+    /** Series label options incl. the theme text colour (new object only when either changes). */
     readonly labelSettings: _angular_core.Signal<{
+        color: string;
         visible: boolean;
         content: (e: {
             category: string;
             value: number;
+            percentage?: number;
         }) => string;
+        position?: "insideEnd" | "outsideEnd";
     }>;
+    /** Connector lines of outside labels: theme coloured when `labelPosition: 'outside'` is set, else the chart default (AB#5622). */
+    private readonly _explicitOutsideLabels;
+    readonly connectors: _angular_core.Signal<{
+        color: string;
+        width: number;
+        padding: number;
+    } | undefined>;
     private updateLabelSettings;
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
@@ -4074,6 +4505,12 @@ interface PieChartConfigResult extends WidgetConfigResult {
     showLabels: boolean;
     showLegend: boolean;
     legendPosition: 'top' | 'bottom' | 'left' | 'right';
+    /** Colour per category (AB#5622); absent = default colours. */
+    categoryColors?: Record<string, string>;
+    /** Slice label position (AB#5622); absent = chart default. */
+    labelPosition?: PieChartLabelPosition;
+    /** Hide labels of slices below this share in percent (AB#5622); absent = all labelled. */
+    hideLabelsBelowPercent?: number;
     filters?: FieldFilterDto[];
 }
 /**
@@ -4100,6 +4537,22 @@ declare class PieChartConfigDialogComponent implements OnInit, AfterViewInit {
     initialCkQueryTarget?: CkQueryTarget;
     initialCkGroupBy?: string;
     initialFilters?: WidgetFilterConfig[];
+    initialCategoryColors?: Record<string, string>;
+    initialLabelPosition?: PieChartLabelPosition;
+    initialHideLabelsBelowPercent?: number;
+    protected readonly addIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly removeIcon: _progress_kendo_svg_icons.SVGIcon;
+    /** Rows of the category colour editor (AB#5622). */
+    categoryColorRows: {
+        id: number;
+        category: string;
+        color: string;
+    }[];
+    private nextCategoryColorId;
+    labelPositions: {
+        value: PieChartLabelPosition | undefined;
+        label: string;
+    }[];
     protected readonly searchIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly chartPieIcon: _progress_kendo_svg_icons.SVGIcon;
     isLoadingInitial: boolean;
@@ -4136,6 +4589,8 @@ declare class PieChartConfigDialogComponent implements OnInit, AfterViewInit {
         legendPosition: "top" | "bottom" | "left" | "right";
         ckQueryTarget: CkQueryTarget;
         ckGroupBy: string;
+        labelPosition: PieChartLabelPosition | undefined;
+        hideLabelsBelowPercent: number | null;
     };
     get isValid(): boolean;
     /** Family of the currently selected query; drives the time-filter toggle's visibility. */
@@ -4155,11 +4610,17 @@ declare class PieChartConfigDialogComponent implements OnInit, AfterViewInit {
      * because the SD path has no dedicated column-introspection endpoint today.
      */
     private fetchColumnsForFamily;
+    addCategoryColor(): void;
+    removeCategoryColor(id: number): void;
+    /** Value of the native colour picker: the row's hex colour, else black (the picker needs a #rrggbb value). */
+    swatchValue(color: string): string;
+    /** The edited category colours; rows without category or colour are dropped; none = undefined. */
+    private categoryColorsResult;
     onFiltersChange(updatedFilters: FieldFilterItem[]): void;
     onSave(): void;
     onCancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieChartConfigDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieChartConfigDialogComponent, "mm-pie-chart-config-dialog", never, { "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; }; "initialChartType": { "alias": "initialChartType"; "required": false; }; "initialCategoryField": { "alias": "initialCategoryField"; "required": false; }; "initialValueField": { "alias": "initialValueField"; "required": false; }; "initialShowLabels": { "alias": "initialShowLabels"; "required": false; }; "initialShowLegend": { "alias": "initialShowLegend"; "required": false; }; "initialLegendPosition": { "alias": "initialLegendPosition"; "required": false; }; "initialCkQueryTarget": { "alias": "initialCkQueryTarget"; "required": false; }; "initialCkGroupBy": { "alias": "initialCkGroupBy"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieChartConfigDialogComponent, "mm-pie-chart-config-dialog", never, { "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; }; "initialChartType": { "alias": "initialChartType"; "required": false; }; "initialCategoryField": { "alias": "initialCategoryField"; "required": false; }; "initialValueField": { "alias": "initialValueField"; "required": false; }; "initialShowLabels": { "alias": "initialShowLabels"; "required": false; }; "initialShowLegend": { "alias": "initialShowLegend"; "required": false; }; "initialLegendPosition": { "alias": "initialLegendPosition"; "required": false; }; "initialCkQueryTarget": { "alias": "initialCkQueryTarget"; "required": false; }; "initialCkGroupBy": { "alias": "initialCkGroupBy"; "required": false; }; "initialFilters": { "alias": "initialFilters"; "required": false; }; "initialCategoryColors": { "alias": "initialCategoryColors"; "required": false; }; "initialLabelPosition": { "alias": "initialLabelPosition"; "required": false; }; "initialHideLabelsBelowPercent": { "alias": "initialHideLabelsBelowPercent"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -4172,6 +4633,8 @@ interface SeriesData {
 }
 declare class BarChartWidgetComponent implements DashboardWidget<BarChartWidgetConfig, SeriesData[]>, OnInit, OnChanges {
     private readonly queryExecutor;
+    /** Text / grid colours of the current theme, re-resolved on a live theme switch (AB#5568). */
+    protected readonly chartTheme: _angular_core.Signal<ChartThemeColors>;
     private static readonly SUPPORTED_ROW_TYPES;
     private readonly stateService;
     private readonly variableService;
@@ -4390,6 +4853,8 @@ interface ValueAxisConfig {
 }
 declare class LineChartWidgetComponent implements DashboardWidget<LineChartWidgetConfig, LineSeriesData[]>, AfterViewInit, OnChanges, OnDestroy {
     private readonly queryExecutor;
+    /** Text / grid colours of the current theme, re-resolved on a live theme switch (AB#5568). */
+    protected readonly chartTheme: _angular_core.Signal<ChartThemeColors>;
     private readonly elementRef;
     private readonly ngZone;
     private resizeObserver?;
@@ -4684,6 +5149,8 @@ interface HeatmapDataItem {
 }
 declare class HeatmapWidgetComponent implements DashboardWidget<HeatmapWidgetConfig, HeatmapDataItem[]>, OnInit, OnChanges {
     private readonly queryExecutor;
+    /** Text / grid colours of the current theme, re-resolved on a live theme switch (AB#5568). */
+    protected readonly chartTheme: _angular_core.Signal<ChartThemeColors>;
     private static readonly SUPPORTED_ROW_TYPES;
     private readonly stateService;
     private readonly variableService;
@@ -4954,6 +5421,7 @@ interface EditableStat {
     suffix?: string;
 }
 declare class StatsGridConfigDialogComponent implements OnInit {
+    protected readonly deleteIcon: _progress_kendo_svg_icons.SVGIcon;
     private readonly windowRef;
     private readonly stateService;
     initialStats?: StatItem[];
@@ -5372,6 +5840,44 @@ declare class MarkdownConfigDialogComponent implements OnInit {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<MarkdownConfigDialogComponent, "mm-markdown-config-dialog", never, { "initialContent": { "alias": "initialContent"; "required": false; }; "initialResolveVariables": { "alias": "initialResolveVariables"; "required": false; }; "initialPadding": { "alias": "initialPadding"; "required": false; }; "initialTextAlign": { "alias": "initialTextAlign"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+type NgxMarkdownModule = typeof ngx_markdown;
+/**
+ * Loads `ngx-markdown` (and with it `marked`) on first use. The bare-specifier dynamic import stays
+ * a real `import()` in the published bundle, so the application bundler puts both libraries into a
+ * lazy chunk that is only fetched once a markdown block is actually rendered.
+ */
+declare function loadNgxMarkdown(): Promise<NgxMarkdownModule>;
+/**
+ * Renders markdown with `ngx-markdown`'s `<markdown>` component, loading `ngx-markdown`/`marked`
+ * lazily (AB#5621) so they stay out of the initial bundle of hosts that show MeshBoards eagerly.
+ *
+ * If the host already provides `MarkdownService` (e.g. `provideMarkdown({...})` at root or on a
+ * route), that configuration is used; otherwise the component provides a default
+ * `provideMarkdown()` itself, so no host setup is required.
+ *
+ * While the library loads nothing is shown; if loading fails, the raw text is shown instead.
+ */
+declare class LazyMarkdownComponent implements OnInit {
+    private readonly injector;
+    private readonly environmentInjector;
+    private readonly destroyRef;
+    /** Markdown source to render. */
+    readonly data: _angular_core.InputSignal<string | null | undefined>;
+    /** True once the `<markdown>` component is attached. */
+    readonly rendered: _angular_core.WritableSignal<boolean>;
+    /** True if `ngx-markdown` could not be loaded; the raw text is shown then. */
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    private outlet;
+    private readonly markdownRef;
+    private ownedInjector;
+    private destroyed;
+    constructor();
+    ngOnInit(): void;
+    private attach;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazyMarkdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LazyMarkdownComponent, "mm-lazy-markdown", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 interface StatusListItem {
     label: string;
     status: string;
@@ -5380,6 +5886,7 @@ interface StatusListItem {
 }
 declare class StatusListWidgetComponent implements DashboardWidget<StatusListWidgetConfig, StatusListItem[]>, OnInit, OnChanges {
     private readonly getEntitiesByCkTypeGQL;
+    private readonly secretSafeNames;
     config: StatusListWidgetConfig;
     private readonly _isLoading;
     private readonly _error;
@@ -5447,6 +5954,7 @@ interface TileValue {
 }
 declare class SummaryCardWidgetComponent implements DashboardWidget<SummaryCardWidgetConfig, TileValue[]>, OnInit, OnChanges {
     private readonly entityGQL;
+    private readonly secretSafeNames;
     private readonly dataService;
     private readonly queryExecutor;
     private readonly stateService;
@@ -5746,6 +6254,40 @@ declare function registerProcessWidget(registry: WidgetRegistryService): void;
  */
 declare function provideProcessWidget(): EnvironmentProviders;
 
+/**
+ * Host translations of the MeshBoard widget texts (AB#5622). Every member is optional; a missing
+ * member keeps the English default, so an app sets only what it translates.
+ */
+interface MeshBoardMessages {
+    /**
+     * Texts of the list inside the table widget (`mm-list-view`): "No records available.", the
+     * pager texts, the toolbar labels and the row action names. Merged over the list's English
+     * defaults (`DEFAULT_LIST_VIEW_MESSAGES`).
+     */
+    tableList?: Partial<ListViewMessages>;
+    /** Placeholder of a table widget without data source / columns. Default: "Table not configured" */
+    tableNotConfigured?: string;
+}
+/** Default texts of {@link MeshBoardMessages} (the list texts default inside `mm-list-view`). */
+declare const DEFAULT_MESHBOARD_MESSAGES: Required<Omit<MeshBoardMessages, 'tableList'>>;
+/**
+ * What a host provides on {@link MESHBOARD_MESSAGES}: a fixed object, or a signal for apps that
+ * switch the language at runtime (the widgets follow it).
+ */
+type MeshBoardMessagesSource = MeshBoardMessages | Signal<MeshBoardMessages | null | undefined>;
+/**
+ * Optional: the host's translations of the MeshBoard widget texts (English without it). Set it
+ * once app-wide, either directly or via `provideMeshBoard({ messages })` /
+ * `provideMeshBoardMessages(messages)`.
+ *
+ * ```ts
+ * providers: [provideMeshBoardMessages({ tableList: { noRecords: 'Keine Einträge vorhanden.', pagerItemsPerPage: 'Einträge pro Seite' } })]
+ * ```
+ */
+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;
+
 /**
  * Registers all built-in widget types with the registry.
  * Called during app initialization.
@@ -5778,6 +6320,11 @@ interface MeshBoardOptions {
     defaultRowHeight?: number;
     /** Default gap between widgets in pixels (default: 16) */
     defaultGap?: number;
+    /**
+     * Host translations of the widget texts (AB#5622), provided as `MESHBOARD_MESSAGES` — e.g. the
+     * table widget's list texts. Fixed object or signal. Absent = English.
+     */
+    messages?: MeshBoardMessagesSource;
 }
 /**
  * Injection token for MeshBoard options
@@ -5807,6 +6354,11 @@ declare const MESHBOARD_TENANT_ID_PROVIDER: InjectionToken<Types.TenantIdProvide
  * ```
  */
 declare function provideMeshBoard(options?: MeshBoardOptions): EnvironmentProviders;
+/**
+ * Provides the host translations of the MeshBoard widget texts (`MESHBOARD_MESSAGES`, AB#5622)
+ * without `provideMeshBoard()` — for apps that register the widgets lazily.
+ */
+declare function provideMeshBoardMessages(messages: MeshBoardMessagesSource): EnvironmentProviders;
 /**
  * Provider function for registering custom widgets.
  * Use this to add your own widget types to MeshBoard.
@@ -5839,6 +6391,44 @@ declare function provideMeshBoard(options?: MeshBoardOptions): EnvironmentProvid
  */
 declare function provideWidgetRegistrations(registrations: WidgetRegistration<AnyWidgetConfig, WidgetConfigResult>[]): EnvironmentProviders;
 
+/**
+ * What a MeshBoard label belongs to (AB#5622):
+ * - `tableCell` — the text of a table widget cell (enum values such as `PAID`);
+ * - `chartCategory` — a category of a pie / donut chart. The resolved text is the slice's name
+ *   everywhere: data labels, legend items and tooltips.
+ */
+type MeshBoardLabelKind = 'tableCell' | 'chartCategory';
+/** One label lookup of {@link MeshBoardLabelResolver}. */
+interface MeshBoardLabelRequest {
+    kind: MeshBoardLabelKind;
+    /** Runtime CK type of the widget's data, when known (table over a runtime entity type); else undefined. */
+    ckTypeId?: string;
+    /** The attribute (column field / category field) the value belongs to, as configured on the widget. */
+    attribute: string;
+    /** The raw value as delivered by the query (e.g. the enum value name `PAID`). */
+    value: string;
+    /** CK value type of the column when the query reports it (`ENUM`, `STRING`, ...). */
+    valueType?: string;
+    /** The text shown without a resolver (e.g. "Paid" for `PAID` in charts, the raw value in tables). */
+    defaultText: string;
+}
+/**
+ * Host hook that translates enum values in MeshBoard tables and chart categories (AB#5622). Same
+ * pattern as the entity forms' `ENTITY_FORM_LABEL_RESOLVER`: return `null`, `undefined` or `''`
+ * to keep {@link MeshBoardLabelRequest.defaultText}. A resolver that throws is logged once and
+ * ignored. Charts call it inside a `computed`, so a resolver that reads a signal (the current
+ * language) re-labels the chart when the signal changes.
+ *
+ * ```ts
+ * { provide: MESHBOARD_LABEL_RESOLVER, useValue: (r) => r.attribute === 'paymentState' ? i18n.enumLabel('PaymentState', r.value) : null }
+ * ```
+ */
+type MeshBoardLabelResolver = (request: MeshBoardLabelRequest) => string | null | undefined;
+/** App-wide {@link MeshBoardLabelResolver}. Not provided = today's texts. */
+declare const MESHBOARD_LABEL_RESOLVER: InjectionToken<MeshBoardLabelResolver>;
+/** Resolves one label; the default text when there is no resolver, no translation, or the resolver throws. */
+declare function resolveMeshBoardLabel(resolver: MeshBoardLabelResolver | null | undefined, request: MeshBoardLabelRequest): string;
+
 /**
  * Component for editing entity selector configurations in MeshBoard settings.
  * Allows adding, editing, and removing entity selectors.
@@ -6094,6 +6684,7 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     protected readonly trashIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly gridLayoutIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly undoIcon: _progress_kendo_svg_icons.SVGIcon;
+    /** Duplicate widget (canonical duplicate icon, AB#5580). */
     protected readonly copyIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly infoCircleIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly arrowUpIcon: _progress_kendo_svg_icons.SVGIcon;
@@ -6118,8 +6709,28 @@ declare class MeshBoardViewComponent implements OnInit, OnDestroy, HasUnsavedCha
     private readonly _hideEntitySelectors;
     protected readonly hideEntitySelectors: _angular_core.Signal<boolean>;
     protected readonly timeRangeLabels: _angular_core.WritableSignal<TimeRangePickerLabels>;
+    /**
+     * How much of the header the host shows: `full` (default) with name and description,
+     * `compact` (controls only, aligned right) or `none` (no header row). A host page that
+     * already names the board (e.g. a tab under a greeting) embeds it compact. Overrides the
+     * route data `meshBoardHeaderMode`, which routes loading the view directly use.
+     */
+    readonly headerMode: _angular_core.InputSignal<MeshBoardHeaderMode | undefined>;
+    private readonly routeHeaderMode;
+    protected readonly effectiveHeaderMode: _angular_core.Signal<MeshBoardHeaderMode>;
+    /**
+     * Whether the view draws its own outer frame: `framed` (default) paints the view background,
+     * the header bar and the grid padding; `plain` leaves all three to the host page, so the
+     * widgets sit on the host surface and align with its gutter (widget frames and the gap between
+     * widgets unchanged). Overrides the route data `meshBoardChrome`.
+     */
+    readonly chrome: _angular_core.InputSignal<MeshBoardChrome | undefined>;
+    private readonly routeChrome;
+    protected readonly effectiveChrome: _angular_core.Signal<MeshBoardChrome>;
     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). */
+    private readonly visibleWidgets;
     protected readonly bannerWidgets: _angular_core.Signal<AnyWidgetConfig[]>;
     protected readonly gridWidgets: _angular_core.Signal<AnyWidgetConfig[]>;
     protected readonly hasGridWidgets: _angular_core.Signal<boolean>;
@@ -6408,7 +7019,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, {}, {}, 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; }; }, {}, never, never, true, [{ directive: typeof i1.UnsavedChangesDirective; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -6555,12 +7166,14 @@ declare class AddWidgetDialogComponent implements OnInit {
 
 /**
  * Dialog for managing multiple MeshBoards.
- * Provides actions to switch, create, rename, and delete MeshBoards.
+ * Provides actions to switch, create, rename, delete, and pin MeshBoards
+ * (pinned boards appear in the host app's end-user navigation).
  */
 declare class MeshBoardManagerDialogComponent implements OnInit {
     private readonly dialogRef;
     private readonly stateService;
     private readonly dialogService;
+    private readonly confirmationService;
     private readonly assetRepoService;
     private readonly jobManagementService;
     private readonly importStrategyDialogService;
@@ -6578,12 +7191,17 @@ declare class MeshBoardManagerDialogComponent implements OnInit {
     protected readonly checkIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly xIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly gridLayoutIcon: _progress_kendo_svg_icons.SVGIcon;
+    /** Export (canonical export icon, AB#5580). */
     protected readonly downloadIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly uploadIcon: _progress_kendo_svg_icons.SVGIcon;
+    /** Duplicate (canonical duplicate icon, AB#5580). */
     protected readonly copyIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly pinIcon: _progress_kendo_svg_icons.SVGIcon;
+    protected readonly unpinIcon: _progress_kendo_svg_icons.SVGIcon;
     protected readonly isExporting: _angular_core.WritableSignal<boolean>;
     protected readonly isImporting: _angular_core.WritableSignal<boolean>;
     protected readonly isDuplicating: _angular_core.WritableSignal<boolean>;
+    protected readonly isPinning: _angular_core.WritableSignal<boolean>;
     protected readonly meshBoards: _angular_core.Signal<PersistedMeshBoard[]>;
     protected readonly currentMeshBoardId: _angular_core.Signal<string | null>;
     protected readonly isLoading: _angular_core.WritableSignal<boolean>;
@@ -6615,6 +7233,14 @@ declare class MeshBoardManagerDialogComponent implements OnInit {
      * Returns the suffix including the marker and JSON, or empty string if none.
      */
     private getEncodedSuffix;
+    /**
+     * Whether a MeshBoard is pinned to the host app's end-user navigation.
+     */
+    isPinned(meshBoard: PersistedMeshBoard): boolean;
+    /**
+     * Pins or unpins a MeshBoard for the host app's end-user navigation.
+     */
+    togglePinned(meshBoard: PersistedMeshBoard): Promise<void>;
     /**
      * Checks if a MeshBoard is being edited.
      */
@@ -6685,5 +7311,1575 @@ declare class MeshBoardManagerDialogComponent implements OnInit {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<MeshBoardManagerDialogComponent, "mm-meshboard-manager-dialog", never, {}, {}, never, never, true, never>;
 }
 
-export { AddWidgetDialogComponent, AiInsightsConfigDialogComponent, AiInsightsService, AiInsightsWidgetComponent, AlertBannerConfigDialogComponent, AlertBannerWidgetComponent, AlertListConfigDialogComponent, AlertListWidgetComponent, AssociationsConfigDialogComponent, AutoRefreshTimerService, BarChartConfigDialogComponent, BarChartWidgetComponent, DEFAULT_TIME_ZONE_MODE, DashboardDataService, DashboardGridService, EditModeStateService, EditWidgetDialogComponent, EntityAssociationsWidgetComponent, EntityCardConfigDialogComponent, EntityCardWidgetComponent, EntityDetailDialogComponent, EntitySelectorEditorComponent, EntitySelectorToolbarComponent, GaugeConfigDialogComponent, GaugeWidgetComponent, HeatmapConfigDialogComponent, HeatmapWidgetComponent, KpiConfigDialogComponent, KpiWidgetComponent, LineChartConfigDialogComponent, LineChartWidgetComponent, MESHBOARD_OPTIONS, MESHBOARD_TENANT_ID_PROVIDER, MarkdownConfigDialogComponent, MarkdownWidgetComponent, MeshBoardDataService, MeshBoardGridService, MeshBoardManagerDialogComponent, MeshBoardPersistenceService, MeshBoardSettingsDialogComponent, MeshBoardSettingsResult, MeshBoardStateService, MeshBoardViewComponent, PieChartConfigDialogComponent, PieChartWidgetComponent, QueryExecutorService, QuerySelectorComponent, RuntimeEntitySelectorComponent, ServiceHealthConfigDialogComponent, ServiceHealthWidgetComponent, StatsGridConfigDialogComponent, StatsGridWidgetComponent, StatusIndicatorConfigDialogComponent, StatusIndicatorWidgetComponent, StatusListConfigDialogComponent, StatusListWidgetComponent, SummaryCardConfigDialogComponent, SummaryCardWidgetComponent, TableConfigDialogComponent, TableWidgetComponent, TableWidgetDataSourceDirective, WidgetFactoryService, WidgetGroupComponent, WidgetGroupConfigDialogComponent, WidgetNotConfiguredComponent, WidgetRegistryService, classifyQuery, provideDefaultWidgets, provideMeshBoard, provideProcessWidget, provideWidgetRegistrations, queryFamily, registerDefaultWidgets, registerProcessWidget };
-export type { AggregationDataSource, AggregationQuery, AggregationType, AiInsightsConfigResult, AiInsightsWidgetConfig, AlertBannerConfigResult, AlertBannerWidgetConfig, AlertListConfigResult, AlertListWidgetConfig, AnyWidgetConfig, AssociationsConfigResult, BarChartColorThreshold, BarChartConfigResult, BarChartSeries, BarChartType, BarChartWidgetConfig, BaseWidgetConfig, CategoryValueItem, ChartReferenceLine, CkQueryResult, CkQueryTarget, CkTypeAttributeInfo, ConfigDialogResult, ConfigResultApplier, ConstructionKitQueryDataSource, DashboardConfig, DashboardWidget, DataSource, DataSourceType, DiagramPropertyMapping, EntityAssociation, EntityAttribute, EntityCardConfigResult, EntityCardWidgetConfig, EntityListWidget, EntitySelectorAttributeMapping, EntitySelectorChildScope, EntitySelectorClearEvent, EntitySelectorConfig, EntitySelectorEvent, EntityWidget, EntityWithAssociationsWidgetConfig, GaugeConfigResult, GaugeRange, GaugeType, GaugeWidgetConfig, GridCell, GridPosition, GroupChildWidgetType, GroupedDataItem, HeatmapAggregation, HeatmapColorMode, HeatmapColorScheme, HeatmapConfigResult, HeatmapWidgetConfig, KpiConfigResult, KpiDataSourceType, KpiQueryMode, KpiValueMode, KpiWidgetConfig, LineChartConfigResult, LineChartType, LineChartWidgetConfig, MarkdownConfigResult, MarkdownTextAlign, MarkdownWidgetConfig, MeshBoardConfig, MeshBoardOptions, MeshBoardTimeFilterConfig, MeshBoardTimeZoneMode, MeshBoardVariable, MeshBoardVariableSource, MeshBoardVariableType, ParentAssociationMode, PersistedDashboard, PersistedMeshBoard, PersistedWidget, PersistedWidgetData, PersistentQueryCellMode, PersistentQueryCellSource, PersistentQueryDataSource, PersistentQueryItem, PieChartConfigResult, PieChartType, PieChartWidgetConfig, ProcessWidgetConfig, Quarter, QueryCell, QueryClassification, QueryColumn, QueryColumnInfo, QueryColumnItem, QueryExecutionOptions, QueryExecutionResult, QueryFamily, QueryKind, QueryResultRow, RelativeTimeUnit, RepeaterDataItem, RepeaterQueryDataSource, RuntimeEntityData, RuntimeEntityDataSource, RuntimeEntitySelectorValue, SeriesAggregationFunction, SeriesResolutionResult, ServiceCallDataSource, ServiceCallType, ServiceHealthConfigResult, ServiceHealthWidgetConfig, StatColor, StatItem, StaticDataSource, StatsGridConfigResult, StatsGridWidgetConfig, StatusIndicatorConfigResult, StatusIndicatorWidgetConfig, StatusListConfigResult, StatusListWidgetConfig, StreamDataExecutionArgs, SummaryCardConfigResult, SummaryCardTile, SummaryCardWidgetConfig, TableColumn, TableColumnStatusIconMapping, TableConfigResult, TableFilterConfig, TableSortConfig, TableWidgetConfig, TargetEntityWithAttributes, TimeRangePickerConfig, TimeRangeSelection, TimeRangeType, UpdateDashboardResult, VariableResolutionError, WidgetConfig, WidgetConfigDialog, WidgetConfigDialogSize, WidgetConfigResult, WidgetCreationOptions, WidgetDataSource, WidgetFilterConfig, WidgetGroupAttributeMappings, WidgetGroupChildTemplate, WidgetGroupConfig, WidgetGroupConfigResult, WidgetGroupLayout, WidgetPersistenceData, WidgetPositionUpdate, WidgetRegistration, WidgetType, WidgetZone };
+/**
+ * Translatable texts of the cockpit widgets (AB#5622): "Attention list", the KPI tiles
+ * ("Adapter status", "CK model state", "Pipeline executions 24 h", and for the system cockpit
+ * "Tenants", "Blueprint updates", "Services healthy", "Version") and "Recent items".
+ *
+ * The widgets are created by the MeshBoard, so a host translates them through
+ * {@link COCKPIT_WIDGET_MESSAGES} (or `provideCockpitWidgetHost({ messages })`); a widget used on
+ * its own also takes a `messages` input, which wins over the token. Both accept a
+ * `Partial<CockpitWidgetMessages>`; members that are missing, `undefined` or `null` keep the
+ * English default from {@link DEFAULT_COCKPIT_WIDGET_MESSAGES}. Members added later will be
+ * optional, so a complete object written for this version keeps compiling.
+ *
+ * Placeholders in braces (`{count}`) are filled with {@link formatCockpitMessage}. Not covered:
+ * the config dialogs (board editors) and the findings of the built-in OctoMesh attention
+ * providers, except "Failed pipeline executions" (`attentionFailedExecutions*`), the service
+ * health (`attentionService*`) and blueprint update (`attentionBlueprintUpdates*`) checks — a host's own
+ * providers bring their own (translated) titles and texts.
+ */
+interface CockpitWidgetMessages {
+    /** BCP 47 locale for numbers on the tiles and the finding count badge. Default: "en-US" */
+    numberLocale: string;
+    /** Viewers without builder roles, instead of role requirements. Default: "Not available" */
+    notAvailable: string;
+    /** Default: "Loading…" */
+    loading: string;
+    /** Default: "No tenant selected." */
+    noTenant: string;
+    /** Severity chip. Default: "Error" */
+    severityError: string;
+    /** Severity chip. Default: "Warning" */
+    severityWarning: string;
+    /** Severity chip. Default: "Info" */
+    severityInfo: string;
+    /** Default: "Checking…" */
+    attentionChecking: string;
+    /** Builders when no check is visible for them. Default: "No health checks are available for your role." */
+    attentionNoChecksForRole: string;
+    /** Chip of the empty state. Default: "All clear" */
+    attentionAllClear: string;
+    /** Text of the empty state. Default: "Nothing needs attention." */
+    attentionNothingNeedsAttention: string;
+    /** Accessible name of the finding list. Default: "Needs attention" */
+    attentionListLabel: string;
+    /** Explain button. Default: "✦ Explain" */
+    attentionExplain: string;
+    /** `{count}` = findings not shown. Default: "and {count} more" */
+    attentionMore: string;
+    /** Accessible name of a finding's count badge; `{count}` = formatted count. Default: "Count: {count}" */
+    attentionCountLabel: string;
+    /** Default: "The health checks could not be loaded." */
+    attentionLoadFailed: string;
+    /** Title; the count is the finding's badge. Default: "Failed pipeline executions in the last 24 h" */
+    attentionFailedExecutionsTitle?: string;
+    /** `{failed}`, `{total}` formatted counts, `{ratio}` formatted percentage. Default: "{failed} of {total} executions failed ({ratio}). The Data Flows list shows which pipelines fail, their execution history the errors." */
+    attentionFailedExecutionsText?: string;
+    /** Appended to the text after a capped read. Default: "Counted over the first {read} of {total} data flows." */
+    attentionFailedExecutionsTruncated?: string;
+    /** Link chip. Default: "Open data flows" */
+    attentionFailedExecutionsLink?: string;
+    /** "✦ Explain" prefill; `{count}` = formatted failed count. Default: "Why did {count} pipeline executions fail in the last 24 hours?" */
+    attentionFailedExecutionsExplain?: string;
+    /** A tile whose query failed. Default: "The figure could not be loaded." */
+    kpiLoadFailed: string;
+    /** Builders without the role / model of the adapter and execution tiles. */
+    kpiNeedsCommunication: string;
+    /** Builders without the role of the CK model tile. Default: "Needs the AdminPanelManagement role." */
+    kpiNeedsAdminPanel: string;
+    /** Default: "Adapters online" */
+    kpiAdaptersLabel: string;
+    /** Default: "{count} hibernated" */
+    kpiAdaptersHibernated: string;
+    /** Default: "{count} edge / local" */
+    kpiAdaptersEdgeLocal: string;
+    /** Default: "{count} not deployed" */
+    kpiAdaptersNotDeployed: string;
+    /** Capped read. Default: "based on the first {read} of {total} adapters" */
+    kpiAdaptersTruncated: string;
+    /** Default: "No adapters" */
+    kpiAdaptersNone: string;
+    /** Default: "None deployed" */
+    kpiAdaptersNoneDeployed: string;
+    /** `{count}` may carry a "≥ " prefix. Default: "{count} offline" */
+    kpiAdaptersOffline: string;
+    /** Default: "All online" */
+    kpiAdaptersAllOnline: string;
+    /** Default: "Pipeline executions 24 h" */
+    kpiExecutionsLabel: string;
+    /** Default: "No executions in the last 24 hours" */
+    kpiExecutionsNone: string;
+    /** Default: "{count} succeeded" */
+    kpiExecutionsSucceeded: string;
+    /** Capped read. Default: "based on the first {read} of {total} data flows" */
+    kpiExecutionsTruncated: string;
+    /** Default: "Idle" */
+    kpiExecutionsIdle: string;
+    /** `{count}` may carry a "≥ " prefix. Default: "{count} failed" */
+    kpiExecutionsFailed: string;
+    /** Default: "No failures" */
+    kpiExecutionsNoFailures: string;
+    /** Accessible sparkline summary. Default: "Executions per hour over the last 24 hours, peak {peak}; {total} executions, {failed} failed" */
+    kpiExecutionsSparkline: string;
+    /** Default: "CK models available" */
+    kpiCkModelsLabel: string;
+    /** Default: "{count} importing" */
+    kpiCkModelsImporting: string;
+    /** Names of failed models with a rest. Default: "{names} and {count} more" */
+    kpiCkModelsMoreNames: string;
+    /** Default: "No models" */
+    kpiCkModelsNone: string;
+    /** Default: "{count} ResolveFailed" */
+    kpiCkModelsResolveFailed: string;
+    /** Default: "Importing" */
+    kpiCkModelsImportingStatus: string;
+    /** Default: "All available" */
+    kpiCkModelsAllAvailable: string;
+    /** Builders without the role of the tenant tile. Default: "Needs the TenantManagement role." */
+    kpiNeedsTenantManagement?: string;
+    /** Default: "Tenants" */
+    kpiTenantsLabel?: string;
+    /** Status chip with child tenants. Default: "Registered" */
+    kpiTenantsRegistered?: string;
+    /** Status chip without child tenants. Default: "No child tenants" */
+    kpiTenantsNone?: string;
+    /** Default: "Blueprint updates" */
+    kpiBlueprintsLabel?: string;
+    /** Default: "Up to date" */
+    kpiBlueprintsUpToDate?: string;
+    /** Default: "{count} available" */
+    kpiBlueprintsAvailable?: string;
+    /** Default: "No blueprints installed" */
+    kpiBlueprintsNone?: string;
+    /** Default: "{count} installed" */
+    kpiBlueprintsInstalled?: string;
+    /** Service-managed blueprints whose newer version their service has not applied yet. Default: "{count} service-managed pending" */
+    kpiBlueprintsServiceManaged?: string;
+    /** Capped catalog read. Default: "based on the first {read} of {total} catalog entries" */
+    kpiBlueprintsTruncated?: string;
+    /**
+     * Shown instead of `loading` once the catalog scan of the "Blueprint updates" tile takes longer
+     * than {@link COCKPIT_KPI_SLOW_LOADING_MS}. Default: "Scanning catalogs…"
+     */
+    kpiBlueprintsScanning?: string;
+    /** Default: "Services healthy" */
+    kpiServicesLabel?: string;
+    /** Default: "All healthy" */
+    kpiServicesAllHealthy?: string;
+    /** Default: "{count} unhealthy" */
+    kpiServicesUnhealthy?: string;
+    /** Default: "{count} degraded" */
+    kpiServicesDegraded?: string;
+    /** Default: "degraded" */
+    serviceStateDegraded?: string;
+    /** Default: "unhealthy" */
+    serviceStateUnhealthy?: string;
+    /** Health endpoint without answer. Default: "not reachable" */
+    serviceStateUnknown?: string;
+    /** Default: "Version" */
+    kpiVersionLabel?: string;
+    /** Default: "No version information" */
+    kpiVersionNone?: string;
+    /** Finding title; `{name}` service, `{state}` one of the serviceState* texts. Default: "{name} service is {state}" */
+    attentionServiceTitle?: string;
+    /** Default: "Its health check reports a problem. The health details list the failing checks." */
+    attentionServiceText?: string;
+    /** Default: "Its health endpoint does not answer. Features that use the service may fail." */
+    attentionServiceUnreachableText?: string;
+    /** Default: "Open health details" */
+    attentionServiceLink?: string;
+    /** Default: "Why is the {name} service {state}?" */
+    attentionServiceExplain?: string;
+    /** Title; the count is the finding's badge. Default: "Blueprint updates available" */
+    attentionBlueprintUpdatesTitle?: string;
+    /** `{list}` = "Name 1.0.0 → 1.1.0, …". Default: "{list}. Updates are applied on the Blueprints page." */
+    attentionBlueprintUpdatesText?: string;
+    /** Default: "Service-managed: {list} — applied by the owning service when it starts." */
+    attentionBlueprintUpdatesServiceManaged?: string;
+    /** Default: "Open blueprints" */
+    attentionBlueprintUpdatesLink?: string;
+    /** Default: "Recently opened items could not be read." */
+    recentLoadFailed: string;
+    /** Accessible name of the list when the widget has no title. Default: "Recently opened" */
+    recentListLabel: string;
+    /** Default: "Nothing opened yet. Pages, entities and boards you open appear here." */
+    recentEmpty: string;
+    /** After the shortcut key. Default: "shows the same list" */
+    recentPaletteHint: string;
+    /** Tooltip of the palette hint. Default: "Open the command palette" */
+    recentPaletteTitle: string;
+    /** Shortcut label when the source names none. Default: "Ctrl K" */
+    recentPaletteShortcut: string;
+    /** Default: "just now" */
+    recentJustNow: string;
+    /** Default: "{count} min ago" */
+    recentMinutesAgo: string;
+    /** Default: "{count} h ago" */
+    recentHoursAgo: string;
+    /** Default: "yesterday" */
+    recentYesterday: string;
+    /** Default: "{count} days ago" */
+    recentDaysAgo: string;
+}
+/** English defaults — today's texts. Complete: every member (optional ones too) has a value. */
+declare const DEFAULT_COCKPIT_WIDGET_MESSAGES: Readonly<Required<CockpitWidgetMessages>>;
+/**
+ * What a host provides on {@link COCKPIT_WIDGET_MESSAGES}: a fixed object, or a signal for apps
+ * that switch the language at runtime (the widgets follow it).
+ */
+type CockpitWidgetMessagesSource = Partial<CockpitWidgetMessages> | Signal<Partial<CockpitWidgetMessages> | null | undefined>;
+/** Optional: the host's translations of the cockpit widget texts (English without it). */
+declare const COCKPIT_WIDGET_MESSAGES: InjectionToken<CockpitWidgetMessagesSource>;
+/**
+ * Merges messages over {@link DEFAULT_COCKPIT_WIDGET_MESSAGES}; missing, `undefined` and `null`
+ * members keep their default, so a widget never renders an empty label.
+ */
+declare function resolveCockpitWidgetMessages(...layers: (Partial<CockpitWidgetMessages> | null | undefined)[]): Required<CockpitWidgetMessages>;
+/** Fills `{name}` placeholders; unknown placeholders stay as they are. */
+declare function formatCockpitMessage(template: string, params?: Record<string, string | number>): string;
+
+/**
+ * Host services of the cockpit widgets (AB#5558). The widgets live in this library and know
+ * nothing about the application that embeds the MeshBoard; the host provides who the viewer is,
+ * where a finding links to and whether "✦ Explain" exists, through these tokens
+ * (`provideCockpitWidgetHost`). Every token is optional: without a host the widgets still render,
+ * but role-gated content stays hidden and findings carry no links.
+ */
+/** Role names the cockpit widgets check (the OctoMesh identity roles). */
+declare const COCKPIT_ROLES: {
+    readonly AdminPanelManagement: "AdminPanelManagement";
+    readonly CommunicationManagement: "CommunicationManagement";
+    readonly TenantManagement: "TenantManagement";
+};
+/** Who is looking at the board. */
+interface CockpitViewerAccess {
+    /** True when the signed-in user has the role (e.g. `CommunicationManagement`). */
+    isInRole(role: string): boolean | Promise<boolean>;
+    /**
+     * True when the viewer works with the platform (the host's "builder" roles). Viewers who are not
+     * get a quiet "Not available" instead of role requirements, and the board collapses cockpit
+     * widgets that have nothing for them. Omitted = not a builder.
+     */
+    isBuilder?(): boolean | Promise<boolean>;
+}
+/**
+ * The viewer's roles. Without it every role check fails — a provider or KPI that needs a role is
+ * never run, so a board embedded in an app without this token shows no builder findings.
+ */
+declare const COCKPIT_VIEWER_ACCESS: InjectionToken<CockpitViewerAccess>;
+/** Query parameters of a {@link CockpitRouteLinkTarget}. */
+type CockpitLinkQueryParams = Readonly<Record<string, string | number | boolean>>;
+/**
+ * A link straight to an application route (AB#5622), for host providers whose findings point at
+ * their own pages, e.g. a pre-filtered list: `{ kind: 'route', path: 'documents', queryParams: {
+ * checkTier: '2' } }`. Navigates through the Angular Router (`routerLink` + `queryParams`).
+ *
+ * `path` is an in-app URL path or router commands (`['/', tenantId, 'documents']`); a scheme
+ * (`https:`) or a protocol-relative start (`//host`) drops the link. Absolute paths are
+ * used as they are; relative ones resolve against the route that renders the board. The host's
+ * `CockpitLinkResolver` sees route targets too and may return a rewritten path (e.g. prefixed
+ * with the tenant root); `null` there keeps `path` — the query parameters always come from the
+ * target.
+ */
+interface CockpitRouteLinkTarget {
+    kind: 'route';
+    path: string | readonly string[];
+    queryParams?: CockpitLinkQueryParams;
+}
+/**
+ * What a finding or KPI links to — semantic targets, so the library holds no application routes.
+ * The host maps them to its own URLs (`CockpitLinkResolver`); `route` targets carry the route
+ * themselves.
+ *
+ * Deployment sites (System.Communication 4.x, AB#5842): the library emits `deployment-site` /
+ * `deployment-sites`. `pool` / `pools` are their deprecated pre-4.x aliases, kept so existing
+ * resolvers still compile; a resolver that answers `null` for a deployment-site kind is asked once
+ * more with the legacy alias (`legacyCockpitLinkTarget`), so hosts keep their links until they map
+ * the new kinds.
+ */
+type CockpitLinkTarget = {
+    kind: 'adapter';
+    rtId: string;
+} | {
+    kind: 'adapters';
+} | {
+    kind: 'deployment-site';
+    rtId: string;
+} | {
+    kind: 'deployment-sites';
+}
+/** @deprecated Since System.Communication 4.x (AB#5842): use `deployment-site`. */
+ | {
+    kind: 'pool';
+    rtId: string;
+}
+/** @deprecated Since System.Communication 4.x (AB#5842): use `deployment-sites`. */
+ | {
+    kind: 'pools';
+} | {
+    kind: 'dataFlows';
+} | {
+    kind: 'ckModels';
+} | {
+    kind: 'tenantSettings';
+} | {
+    kind: 'secretsReEntry';
+}
+/** The tenant's child tenants (system cockpit, AB#5558). */
+ | {
+    kind: 'tenants';
+}
+/** Blueprints installed on the tenant (system cockpit, AB#5558). */
+ | {
+    kind: 'blueprints';
+}
+/** Health detail of one platform service (`identity`, `asset-repository`, `bot`, `communication-controller`). */
+ | {
+    kind: 'serviceHealth';
+    service: string;
+} | CockpitRouteLinkTarget;
+/**
+ * The deprecated pre-4.x alias of a deployment-site target (`deployment-site` → `pool`,
+ * `deployment-sites` → `pools`), or `null` for every other target. Used as the fallback when a
+ * host's resolver has no page for the new kind yet (AB#5842).
+ */
+declare function legacyCockpitLinkTarget(target: CockpitLinkTarget): CockpitLinkTarget | null;
+/** A link target resolved for `routerLink` (path or commands) and `queryParams`. */
+interface CockpitResolvedLink {
+    path: string | string[];
+    queryParams?: CockpitLinkQueryParams;
+}
+/** Maps a link target to an application URL. */
+interface CockpitLinkResolver {
+    /**
+     * Router URL of the target for the tenant (e.g. `/acme/communication/adapters`), or `null` when
+     * the host has no page for it — the link chip is then left out. For `route` targets `null`
+     * means "use the target's path as it is".
+     */
+    resolve(target: CockpitLinkTarget, tenantId: string): string | null;
+}
+/** The host's link resolver; without it findings and KPI tiles carry no links. */
+declare const COCKPIT_LINK_RESOLVER: InjectionToken<CockpitLinkResolver>;
+/** What "✦ Explain" hands to the host's assistant. */
+interface CockpitExplainTarget {
+    /** Human readable name of the object or finding. */
+    label: string;
+    /** Runtime id, when the finding is about one entity. */
+    rtId?: string;
+    /** CK type id of that entity. */
+    ckTypeId?: string;
+    /** Composer prefill, e.g. "Why is the adapter "plc-07" offline?". */
+    prompt?: string;
+}
+/** The host's assistant entry point. */
+interface CockpitExplainHandler {
+    /** False hides every "✦ Explain" button (the assistant is disabled). */
+    readonly enabled: boolean;
+    explain(target: CockpitExplainTarget): void;
+}
+/** Optional: without it the attention list shows no "✦ Explain" buttons. */
+declare const COCKPIT_EXPLAIN_HANDLER: InjectionToken<CockpitExplainHandler>;
+/** What a recent item points at (drives the row glyph). */
+type CockpitRecentItemKind = 'page' | 'entity' | 'board';
+/** One row of the "Recent items" widget, already checked by the host for the viewer. */
+interface CockpitRecentItem {
+    /** Stable key (e.g. the router URL without query). */
+    key: string;
+    kind: CockpitRecentItemKind;
+    /** What the viewer opened, e.g. "Mesh Adapter". */
+    label: string;
+    /** What it is, e.g. "MeshBoard" or "Integration › Adapters". */
+    kindLabel: string;
+    /** Epoch milliseconds of the last visit (shown as relative time). */
+    lastVisitedAt: number;
+    /** Real href of the link, so middle-click, Cmd/Ctrl-click and the context menu work. */
+    href: string;
+}
+/**
+ * The viewer's recently opened places — a per-user history the board does not store. The host
+ * owns it (the Refinery Studio: the same history as the empty Cmd+K palette), re-checks every
+ * entry against what the viewer may still open and decides how an entry opens.
+ */
+interface CockpitRecentItemsSource {
+    /** Changes whenever the history changes; the widget then re-reads {@link items}. */
+    readonly revision?: Signal<unknown>;
+    /** Most recently opened first, at most `limit`, only entries the viewer may still open. */
+    items(limit: number): Promise<CockpitRecentItem[]>;
+    /** Opens an entry on a plain left click (modified clicks are left to the browser). */
+    open(item: CockpitRecentItem): void | Promise<void>;
+    /** Optional: opens the host's command palette, offered as "⌘K shows the same list". */
+    openPalette?(): void;
+    /** Label of the palette shortcut, e.g. "⌘K" or "Ctrl K" (default "Ctrl K"). */
+    readonly paletteShortcut?: string;
+}
+/** The host's recent items; without it the "Recent items" widget says "Not available" and collapses. */
+declare const COCKPIT_RECENT_ITEMS: InjectionToken<CockpitRecentItemsSource>;
+/** One entry of the "Version" tile, e.g. `{ label: 'Refinery Studio', version: '3.4.120' }`. */
+interface CockpitVersionEntry {
+    label: string;
+    version: string;
+}
+/**
+ * Versions the host knows (AB#5558, system cockpit): its own build and whatever else it can tell.
+ * The backend services expose no version endpoint, so the library has nothing of its own to add.
+ */
+interface CockpitVersionSource {
+    /** Most important first: the first entry is the tile's value. */
+    entries(): CockpitVersionEntry[] | Promise<CockpitVersionEntry[]>;
+}
+/** The host's versions; without it the "Version" tile says "Not available" and collapses. */
+declare const COCKPIT_VERSION_SOURCE: InjectionToken<CockpitVersionSource>;
+/** The host services in one call (`providers: [...provideCockpitWidgetHost({...})]`). */
+interface CockpitWidgetHost {
+    access?: () => CockpitViewerAccess;
+    links?: () => CockpitLinkResolver;
+    explain?: () => CockpitExplainHandler;
+    recents?: () => CockpitRecentItemsSource;
+    /** Versions for the "Version" tile (AB#5558). */
+    versions?: () => CockpitVersionSource;
+    /** Translated widget texts (AB#5622), fixed or as a signal that follows the language. */
+    messages?: () => CockpitWidgetMessagesSource;
+}
+/**
+ * Provides the host services of the cockpit widgets. The factories run in an injection context,
+ * so they may `inject()` the application's services:
+ *
+ * ```ts
+ * provideCockpitWidgetHost({
+ *   access: () => { const auth = inject(AuthorizeService); return { isInRole: r => auth.isInRole(r) }; },
+ *   links: () => new StudioCockpitLinks()
+ * })
+ * ```
+ */
+declare function provideCockpitWidgetHost(host: CockpitWidgetHost): Provider[];
+
+/**
+ * The cockpit widgets' view of their host (AB#5558): tenant, roles, CK models, links and the
+ * assistant. Every check fails closed — a missing host token, a failing role or model lookup
+ * means "not allowed", so a provider is skipped rather than shown to the wrong viewer.
+ */
+declare class CockpitContextService {
+    private readonly tenantIdProvider;
+    private readonly access;
+    private readonly links;
+    private readonly explainHandler;
+    private readonly ckModelService;
+    private readonly configuration;
+    /** The current tenant, or `null` when the host provides none. */
+    tenantId(): Promise<string | null>;
+    /** True when the viewer has every role and the tenant has every CK model. */
+    allows(roles: readonly string[], models?: readonly string[]): Promise<boolean>;
+    /**
+     * Whether `tenantId` is the installation's system tenant (`systemTenantId` of the platform
+     * configuration, `octosystem` when the host has none). Checks about the whole installation
+     * (service health, AB#5558) run only there.
+     */
+    isSystemTenant(tenantId: string): boolean;
+    /** Whether the viewer is a builder (`CockpitViewerAccess.isBuilder`); fails closed. */
+    isBuilder(): Promise<boolean>;
+    /**
+     * Router URL of a link target, or `null` (no resolver, or the host has no such page). A `route`
+     * target always resolves: the host's rewrite or its own path, with the query parameters
+     * appended (`/acme/documents?checkTier=2`) — for `routerLink` prefer {@link resolveLinkTarget},
+     * which keeps them apart.
+     */
+    resolveLink(target: CockpitLinkTarget, tenantId: string): string | null;
+    /**
+     * A link target resolved for `routerLink` + `queryParams` (AB#5622), or `null` when there is no
+     * page for it. Semantic targets go through the host's `CockpitLinkResolver`; `route` targets
+     * keep their path unless the resolver rewrites it, and always keep their query parameters.
+     */
+    resolveLinkTarget(target: CockpitLinkTarget, tenantId: string): CockpitResolvedLink | null;
+    private resolveWithHost;
+    /** Whether "✦ Explain" buttons are shown. */
+    get explainEnabled(): boolean;
+    explain(target: CockpitExplainTarget): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitContextService>;
+}
+
+/** Severity of a finding; drives the colour bar and the status chip. */
+type AttentionSeverity = 'error' | 'warning' | 'info';
+/** Order of the findings: errors first. */
+declare const ATTENTION_SEVERITY_ORDER: Record<AttentionSeverity, number>;
+/** A link chip on a finding: label plus a semantic target the host resolves (`CockpitLinkResolver`). */
+interface AttentionLink {
+    label: string;
+    target: CockpitLinkTarget;
+}
+/**
+ * One rule-based health finding (ui-concept §5.5 phase 1): severity, one line, an explanation and
+ * links to the affected objects. A finding never claims more than its provider's single query
+ * showed.
+ */
+interface AttentionFinding {
+    /** Stable id, `<provider id>` or `<provider id>:<sub-key>`. */
+    id: string;
+    severity: AttentionSeverity;
+    title: string;
+    text: string;
+    /**
+     * How many objects the finding is about (AB#5622), shown as a badge next to the title — e.g. the
+     * open items of a work queue. Omitted = no badge (the built-in providers name the count in the
+     * title instead).
+     */
+    count?: number;
+    links: AttentionLink[];
+    /** What "✦ Explain" hands to the host's assistant (only shown when the host enables it). */
+    explain?: CockpitExplainTarget;
+}
+/** What every provider receives. */
+interface AttentionContext {
+    tenantId: string;
+}
+/**
+ * A source of findings for the "Attention list" widget. Contract:
+ *
+ * - `isVisible` checks what the viewer needs to **open** what the finding links to (roles, CK
+ *   models) via `CockpitContextService.allows`; a provider that is not visible is never loaded,
+ *   so viewers only see findings about objects they may see.
+ * - `load` runs exactly **one** query (GraphQL or REST) and emits the findings once; an empty
+ *   array means "nothing to report" (no placeholder findings).
+ * - Errors are swallowed by `CockpitAttentionService` (logged, provider skipped).
+ *
+ * Library providers cover the generic platform checks; a host adds its own with
+ * `{ provide: COCKPIT_ATTENTION_PROVIDERS, useClass: MyProvider, multi: true }`.
+ */
+interface AttentionProvider {
+    /** Stable id, persisted in the widget config (`providerIds`). Never rename. */
+    readonly id: string;
+    /** Name in the widget's config dialog. */
+    readonly label: string;
+    /** One line in the config dialog: what is checked and who sees it. */
+    readonly description: string;
+    isVisible(context: AttentionContext): Promise<boolean>;
+    load(context: AttentionContext): Observable<AttentionFinding[]>;
+}
+/** Multi provider token of the attention sources (built-in ones come with `provideCockpitWidgets()`). */
+declare const COCKPIT_ATTENTION_PROVIDERS: InjectionToken<AttentionProvider[]>;
+/** Sorts findings by severity, keeping the provider order within one severity. */
+declare function sortAttentionFindings(findings: AttentionFinding[]): AttentionFinding[];
+/**
+ * "pool-a, pool-b and 3 more" — names of the affected objects, capped at `max`; `total` counts
+ * objects whose names were not fetched.
+ */
+declare function nameList(names: string[], max?: number, total?: number): string;
+/** "1 pool" / "3 pools". */
+declare function plural(count: number, singular: string, pluralForm?: string): string;
+/** "3 adapters", or "≥ 3 adapters" when the count comes from a capped read. */
+declare function countLabel(count: number, singular: string, atLeast?: boolean, pluralForm?: string): string;
+
+/** Name and description of a registered provider (for the config dialog). */
+interface AttentionProviderInfo {
+    id: string;
+    label: string;
+    description: string;
+}
+/** What the attention list shows while and after its providers run. */
+interface AttentionState {
+    /** Findings so far, sorted error → warning → info. */
+    findings: AttentionFinding[];
+    /** True while a visible provider has not answered yet. */
+    loading: boolean;
+    /** Providers the viewer may see (0: nothing can be checked for this viewer). */
+    visibleProviders: number;
+}
+/**
+ * Runs the attention providers (AB#5558, from the Home cockpit of AB#5545). Each provider is
+ * checked for visibility first (roles / CK models), then loaded once; providers run in parallel
+ * and their findings stream in, sorted by severity. A failing provider only removes its own
+ * findings.
+ */
+declare class CockpitAttentionService {
+    private readonly providers;
+    /** Every registered provider, in registration order. */
+    availableProviders(): AttentionProviderInfo[];
+    /**
+     * Runs the providers named in `providerIds` (all when empty / undefined; unknown ids are
+     * ignored, so a board saved with a provider the host no longer has still loads).
+     */
+    state(context: AttentionContext, providerIds?: readonly string[] | null): Observable<AttentionState>;
+    /** Findings only (the Home fallback strip). */
+    findings(context: AttentionContext, providerIds?: readonly string[] | null): Observable<AttentionFinding[]>;
+    private run;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitAttentionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitAttentionService>;
+}
+/** The providers a widget runs: all when `ids` is empty, else the named ones in registration order. */
+declare function selectProviders(providers: readonly AttentionProvider[], ids?: readonly string[] | null): AttentionProvider[];
+
+/**
+ * CK models in `ResolveFailed`: their data is intact, but their types are not served (typically
+ * after a dependency such as System was bumped). Links to the model libraries, so it needs the
+ * same role as that page (AdminPanelManagement). Shares its query with the "CK model state" KPI.
+ */
+declare class CkModelsResolveFailedAttentionProvider implements AttentionProvider {
+    private readonly context;
+    private readonly ckModelStates;
+    readonly id = "ck-models-resolve-failed";
+    readonly label = "CK models in ResolveFailed";
+    readonly description = "Construction Kit models whose types are not served. Viewers with AdminPanelManagement.";
+    isVisible(): Promise<boolean>;
+    load(context: AttentionContext): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CkModelsResolveFailedAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CkModelsResolveFailedAttentionProvider>;
+}
+
+/**
+ * Adapters in error (deployment or configuration failed) and adapters expected to run that stayed
+ * offline (Helm-deployed and edge/local alike). One query (shared with the "Adapter status" KPI),
+ * up to two findings; capped reads say "≥". Needs what the adapters page needs.
+ */
+declare class AdaptersAttentionProvider implements AttentionProvider {
+    private readonly context;
+    private readonly adapterStates;
+    readonly id = "adapters";
+    readonly label = "Adapters in error or offline";
+    readonly description = "Failed deployments or configurations, and adapters offline for more than 10 minutes. Viewers with CommunicationManagement.";
+    isVisible(): Promise<boolean>;
+    load(context: AttentionContext): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AdaptersAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AdaptersAttentionProvider>;
+}
+
+/**
+ * Deployment sites (`System.Communication/DeploymentSite`, called "pools" before
+ * System.Communication 4.x) no Communication Operator has registered for: the adapters and
+ * applications they host are not rolled out. Needs what the deployment sites page needs
+ * (CommunicationManagement + System.Communication).
+ *
+ * The class name and the provider id `pools-unregistered` keep the pre-4.x wording on purpose:
+ * the id is persisted in attention-list widget configs (`providerIds`) and must never change
+ * (AB#5842).
+ */
+declare class UnregisteredPoolsAttentionProvider implements AttentionProvider {
+    private readonly context;
+    private readonly sitesGql;
+    /** Persisted in widget configs — stable since AB#5558, deliberately not renamed in AB#5842. */
+    readonly id = "pools-unregistered";
+    readonly label = "Deployment sites not registered";
+    readonly description = "Deployment sites without a connected Communication Operator. Viewers with CommunicationManagement.";
+    isVisible(): Promise<boolean>;
+    load(): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UnregisteredPoolsAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UnregisteredPoolsAttentionProvider>;
+}
+
+/** Thresholds of the "Failed pipeline executions" check (AB#5622). */
+interface FailedExecutionsAttentionOptions {
+    /** Failed executions in the last 24 h from which a finding is shown (warning). Default: 10 */
+    minFailed: number;
+    /** Failed executions from which the finding is an error. `null` = never by count. Default: 1000 */
+    errorFailed: number | null;
+    /**
+     * Share of failed executions (0–1, of all executions in 24 h) from which the finding is an error,
+     * once `minFailed` is reached. `null` = never by ratio. Default: 0.2 (20 %)
+     */
+    errorRatio: number | null;
+}
+/** Defaults: a warning from 10 failures, an error from 1,000 failures or a failure share of 20 %. */
+declare const DEFAULT_FAILED_EXECUTIONS_OPTIONS: Readonly<FailedExecutionsAttentionOptions>;
+/**
+ * Optional: the host's thresholds of the "Failed pipeline executions" check; missing members keep
+ * {@link DEFAULT_FAILED_EXECUTIONS_OPTIONS}.
+ */
+declare const COCKPIT_FAILED_EXECUTIONS_OPTIONS: InjectionToken<Partial<FailedExecutionsAttentionOptions>>;
+/** The finding's severity for the counts, or `null` when the counts stay below the thresholds. */
+declare function failedExecutionsSeverity(failed: number, total: number, options: FailedExecutionsAttentionOptions): 'error' | 'warning' | null;
+/**
+ * Failed pipeline executions in the last 24 hours above a threshold (AB#5622): the same data and
+ * counting as the "Pipeline executions 24 h" KPI, whose request it shares
+ * (`CockpitDataFlowExecutionsService`). Texts from `COCKPIT_WIDGET_MESSAGES`, thresholds from
+ * `COCKPIT_FAILED_EXECUTIONS_OPTIONS`. Needs what the Data Flows page needs.
+ */
+declare class FailedExecutionsAttentionProvider implements AttentionProvider {
+    private readonly context;
+    private readonly executions;
+    private readonly messagesSource;
+    private readonly options;
+    readonly id = "pipeline-executions-failed";
+    readonly label = "Failed pipeline executions";
+    readonly description = "Pipeline executions that failed in the last 24 hours, above a threshold. Viewers with CommunicationManagement.";
+    isVisible(): Promise<boolean>;
+    load(context: AttentionContext): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FailedExecutionsAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FailedExecutionsAttentionProvider>;
+}
+
+/**
+ * An unconfigured optional service is an empty URL; older platform-services answered `/` (same
+ * rule as the Studio's Tenant Features panel).
+ */
+declare function isServiceConfigured(url: string | undefined | null): boolean;
+/** Capabilities switched on for the tenant whose service is not part of this installation. */
+declare function enabledButNotInstalled(status: TenantFeaturesStatus | null, config: {
+    reportingServices?: string | null;
+    aiServices?: string | null;
+} | undefined): string[];
+/**
+ * A capability enabled for the tenant whose service is not installed: the tenant delete/detach
+ * guard keeps refusing (AB#4255). One REST call — the aggregate feature status (AB#4884). Links
+ * to the tenant settings, so it needs TenantManagement.
+ */
+declare class FeaturesNotInstalledAttentionProvider implements AttentionProvider {
+    private readonly context;
+    private readonly assetRepoService;
+    private readonly configurationService;
+    readonly id = "features-not-installed";
+    readonly label = "Features enabled but not installed";
+    readonly description = "Reporting, AI Services or Stream Data enabled for the tenant without the service. Viewers with TenantManagement.";
+    isVisible(): Promise<boolean>;
+    load(context: AttentionContext): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeaturesNotInstalledAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FeaturesNotInstalledAttentionProvider>;
+}
+
+/**
+ * Platform services whose health check is not Healthy (system cockpit, AB#5558): one finding per
+ * service — unhealthy or not answering is an error, degraded a warning — linking to the service's
+ * health details. The services serve the whole installation, so the check runs on the system
+ * tenant only (tenant cockpits are unchanged). Shares its requests with the "Services healthy" KPI.
+ */
+declare class ServicesHealthAttentionProvider implements AttentionProvider {
+    private readonly context;
+    /** Resolved on first load: hosts and tests that never run the check need no data providers. */
+    private readonly injector;
+    private readonly messagesSource;
+    readonly id = "services-unhealthy";
+    readonly label = "Platform services with problems";
+    readonly description = "Identity, Asset Repository, Bot or Communication Controller not healthy. System tenant only.";
+    isVisible(context: AttentionContext): Promise<boolean>;
+    load(): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ServicesHealthAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ServicesHealthAttentionProvider>;
+}
+
+/**
+ * Installed blueprints with a newer catalog version (system cockpit, AB#5558): one info finding
+ * with the count as badge, linking to the installed blueprints. Service-managed blueprints
+ * (`System.*`) are named separately — their service applies them. Runs on the system tenant only
+ * for now (it reads the catalogs, so tenant cockpits do not pay for it); same role as the
+ * Blueprints pages. Shares its request with the "Blueprint updates" KPI.
+ */
+declare class BlueprintUpdatesAttentionProvider implements AttentionProvider {
+    private readonly context;
+    /** Resolved on first load: hosts and tests that never run the check need no data providers. */
+    private readonly injector;
+    private readonly messagesSource;
+    readonly id = "blueprint-updates";
+    readonly label = "Blueprint updates available";
+    readonly description = "Installed blueprints with a newer version in the catalogs. System tenant, viewers with AdminPanelManagement.";
+    isVisible(context: AttentionContext): Promise<boolean>;
+    load(context: AttentionContext): Observable<AttentionFinding[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlueprintUpdatesAttentionProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BlueprintUpdatesAttentionProvider>;
+}
+
+type CockpitBlueprintStatusQueryDto = {
+    __typename?: 'OctoQuery';
+    blueprints?: {
+        __typename?: 'BlueprintsQuery';
+        installations: Array<{
+            __typename?: 'BlueprintInstallation';
+            blueprintId: string;
+            isDependency: boolean;
+        }>;
+        list: {
+            __typename?: 'BlueprintListResponse';
+            totalCount: number;
+            items: Array<{
+                __typename?: 'Blueprint';
+                name: string;
+                version: string;
+            }>;
+        };
+    } | null;
+};
+
+/** Catalog entries read with the installations (one page; the catalog lists one entry per name and version). */
+declare const COCKPIT_BLUEPRINT_CATALOG_LIMIT = 500;
+/**
+ * Blueprints whose name starts with `System.` are service-managed: the owning service applies and
+ * rolls them forward per tenant (mirrors `BlueprintIdExtensions.IsServiceManaged`).
+ */
+declare const SERVICE_MANAGED_BLUEPRINT_PREFIX = "System.";
+/** One installed blueprint with the highest version the catalogs offer for its name. */
+interface CockpitBlueprintUpdate {
+    name: string;
+    installedVersion: string;
+    availableVersion: string;
+    isServiceManaged: boolean;
+}
+/** Installed blueprints of the tenant compared with the catalogs (AB#5558, system cockpit). */
+interface CockpitBlueprintStatus {
+    /** Installed root blueprints (dependencies pulled in by another blueprint are not counted). */
+    installed: number;
+    /** Installed blueprints with a strictly higher catalog version; installed by the tenant first, then service-managed. */
+    updates: CockpitBlueprintUpdate[];
+    /** Catalog entries read and available; more available than read = updates may be missing. */
+    catalogRead: number;
+    catalogTotal: number;
+}
+/**
+ * `Name-Version` → parts. Splits at the last dash, like the Studio's blueprint pages (a `CkVersion`
+ * never contains a dash).
+ */
+declare function splitBlueprintId(blueprintId: string): {
+    name: string;
+    version: string;
+};
+/**
+ * Compares two blueprint versions like the backend's `CkVersion` (`Major.Minor.Revision`,
+ * numeric, missing components 0): negative when `a` is older, positive when newer. A string
+ * comparison would rate `2.10.0` below `2.9.0` (AB#4837).
+ */
+declare function compareBlueprintVersions(a: string, b: string): number;
+/** The status from one `cockpitBlueprintStatus` answer. */
+declare function toBlueprintStatus(data: CockpitBlueprintStatusQueryDto | null | undefined): CockpitBlueprintStatus;
+/**
+ * The tenant's blueprint status, shared for a few seconds per tenant between the "Blueprint
+ * updates" KPI and the attention check.
+ */
+declare class CockpitBlueprintStatusService {
+    private readonly gql;
+    private readonly shared;
+    status(tenantId: string, now?: number): Observable<CockpitBlueprintStatus>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitBlueprintStatusService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitBlueprintStatusService>;
+}
+
+/** Child tenants of the current tenant (the system tenant: every tenant of the installation). */
+interface CockpitChildTenants {
+    total: number;
+    /** Ids of the first tenants (for the detail line). */
+    firstIds: string[];
+}
+/** Tenant ids read with the count. */
+declare const COCKPIT_CHILD_TENANT_IDS = 3;
+/**
+ * Child tenant count (AB#5558, system cockpit) from the asset repository's tenant list
+ * (`GET {tenantId}/v1/tenants`, the Child Tenants page). The list only knows id and database —
+ * there is no per-tenant state (enabled, mode, health) to group by.
+ */
+declare class CockpitChildTenantsService {
+    private readonly assetRepo;
+    childTenants(): Observable<CockpitChildTenants>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitChildTenantsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitChildTenantsService>;
+}
+
+/** Platform services the cockpit checks (the keys of the Studio's `health/:serviceType` page). */
+type CockpitServiceKey = 'identity' | 'asset-repository' | 'bot' | 'communication-controller';
+/** Health of one platform service. `unknown`: the health endpoint did not answer. */
+type CockpitServiceHealthStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
+interface CockpitServiceHealth {
+    service: CockpitServiceKey;
+    /** English display name ("Identity"). */
+    name: string;
+    status: CockpitServiceHealthStatus;
+}
+/** Display names, in check order. */
+declare const COCKPIT_SERVICE_NAMES: Readonly<Record<CockpitServiceKey, string>>;
+/** `HealthCheck` → status (`null` = no answer). */
+declare function toServiceHealthStatus(check: HealthCheck | null | undefined): CockpitServiceHealthStatus;
+/**
+ * Health of the platform services (AB#5558, system cockpit): the same `/health` endpoints as the
+ * MeshBoard's service health tiles, all at once, shared for a few seconds between the "Services"
+ * KPI and the attention check. Optional services that are not part of the installation (empty
+ * URL, or `/` from older platform-services) are left out.
+ */
+declare class CockpitServiceHealthService {
+    private readonly health;
+    private readonly configuration;
+    private shared;
+    services(now?: number): Observable<CockpitServiceHealth[]>;
+    private check;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitServiceHealthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitServiceHealthService>;
+}
+
+type CockpitAdapterStatesQueryDto = {
+    __typename?: 'OctoQuery';
+    runtime?: {
+        __typename?: 'RuntimeModelQuery';
+        systemCommunicationAdapter?: {
+            __typename?: 'SystemCommunicationAdapterConnection';
+            totalCount?: number | null;
+            items?: Array<{
+                __typename?: 'SystemCommunicationAdapter';
+                rtId: any;
+                name?: string | null;
+                communicationState: Types.SystemCommunicationCommunicationStateDto;
+                communicationStateTimestamp?: any | null;
+                deploymentState: Types.SystemCommunicationDeploymentStateDto;
+                configurationState: Types.SystemCommunicationConfigurationStateDto;
+                lifecycleState: Types.SystemCommunicationLifecycleStateDto;
+            } | null> | null;
+        } | null;
+    } | null;
+};
+
+/** One adapter row of `cockpitAdapterStates`. */
+type CockpitAdapterState = NonNullable<NonNullable<NonNullable<NonNullable<CockpitAdapterStatesQueryDto['runtime']>['systemCommunicationAdapter']>['items']>[number]>;
+/** The adapters read for the cockpit and how many the tenant has in total. */
+interface CockpitAdapterStates {
+    states: CockpitAdapterState[];
+    /** `totalCount` of the connection; larger than `states.length` when the read was capped. */
+    totalCount: number;
+}
+/** Upper bound of adapters read; beyond it the KPI and findings say "≥" / "first N". */
+declare const COCKPIT_ADAPTER_LIMIT = 500;
+/** A running adapter offline for longer than this is reported (ui-concept §5.5). */
+declare const ADAPTER_OFFLINE_GRACE_MS: number;
+/**
+ * The adapter states behind the "Adapter status" KPI and the adapters provider of the attention
+ * list. Both ask within the same board load, so one request per tenant is shared for a few
+ * seconds. Keyed by tenant: the service is a root singleton and a tenant switch must never show
+ * the previous tenant's adapters.
+ */
+declare class CockpitAdapterStatesService {
+    private readonly gql;
+    private readonly shared;
+    states(tenantId: string, now?: number): Observable<CockpitAdapterStates>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitAdapterStatesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitAdapterStatesService>;
+}
+/** Adapters whose deployment or configuration failed. */
+declare function adaptersInError<T extends Pick<CockpitAdapterState, 'deploymentState' | 'configurationState'>>(states: T[]): T[];
+/**
+ * Adapters expected to run that have not been online for the grace period (Helm-deployed and
+ * edge/local alike, see `utils/adapter-online.ts`); on-demand adapters at rest are not reported.
+ */
+declare function adaptersOffline<T extends Pick<CockpitAdapterState, 'communicationState' | 'deploymentState' | 'lifecycleState' | 'communicationStateTimestamp'>>(states: T[], now: number): T[];
+
+/** A data flow of `cockpitDataFlowExecutions`: its child pipelines with statistics and latest execution. */
+interface CockpitDataFlowRow {
+    children?: {
+        items?: (unknown | null)[] | null;
+    } | null;
+}
+/** The data flows read for the cockpit and how many the tenant has in total. */
+interface CockpitDataFlowExecutions {
+    flows: CockpitDataFlowRow[];
+    /** `totalCount` of the connection; larger than `flows.length` when the read was capped. */
+    totalCount: number;
+}
+/** Executions of the last 24 hours, summed over the data flows read. */
+interface CockpitExecutionCounts {
+    succeeded: number;
+    failed: number;
+}
+/** Upper bound of data flows read for the executions KPI; beyond it the tile says "≥". */
+declare const COCKPIT_DATA_FLOW_LIMIT = 500;
+/**
+ * The data flows behind the "Pipeline executions 24 h" KPI and the failed-executions provider of
+ * the attention list (AB#5622). Both ask within the same board load, so one request per tenant
+ * is shared for a few seconds. Keyed by tenant; a failed request is not kept, so the next board
+ * load asks again.
+ */
+declare class CockpitDataFlowExecutionsService {
+    private readonly gql;
+    private readonly shared;
+    executions(tenantId: string, now?: number): Observable<CockpitDataFlowExecutions>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitDataFlowExecutionsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitDataFlowExecutionsService>;
+}
+/**
+ * Executions of the last 24 hours over all flows, counted exactly like the Studio's Data Flows
+ * list (`countPipelineExecutions` per data flow), so the KPI, the attention list and the list agree.
+ */
+declare function countFlowExecutions(flows: CockpitDataFlowRow[]): CockpitExecutionCounts;
+
+/** Status of a KPI tile, rendered as a chip (dot + label, never colour alone). */
+type CockpitKpiStatus = 'success' | 'warning' | 'error' | 'neutral';
+/** One cockpit KPI (a widget tile, or a tile of the Studio's Home fallback strip). */
+interface CockpitKpi {
+    id: string;
+    label: string;
+    /** Display value, already formatted (tabular numerals). */
+    value: string;
+    /** Secondary line under the value. */
+    detail?: string;
+    status: CockpitKpiStatus;
+    statusLabel: string;
+    /** Page the tile opens (resolved by the host). */
+    link?: CockpitLinkTarget;
+    /** Hourly values (oldest first) for the sparkline. */
+    sparkline?: number[];
+    /** Accessible summary of the sparkline, including failures. */
+    sparklineLabel?: string;
+}
+/** Counts of `cockpitCkModelStates`. */
+interface CockpitCkModelCounts {
+    total: number;
+    available: number;
+    importing: number;
+    resolveFailed: number;
+    /** Full names of (the first) models in ResolveFailed. */
+    resolveFailedNames: string[];
+}
+/** "1,284" (en-US), or in the given BCP 47 locale ("1.284" for de-DE). */
+declare function formatCount(value: number, locale?: string): string;
+/** "based on the first 500 of 620 adapters" when a read was capped, else undefined. */
+declare function truncationNote(read: number, total: number, noun: string): string | undefined;
+/**
+ * "Adapter status x / y" with the one adapter online rule (`utils/adapter-online.ts`): y counts
+ * the adapters expected to run — Helm-deployed, online edge/local ones and registered adapters
+ * without a Helm chart — x those online. On-demand adapters at rest are offline on purpose and do
+ * not warn. Texts from `messages` (English by default, AB#5622).
+ */
+declare function adapterKpi({ states, totalCount }: CockpitAdapterStates, messages?: CockpitWidgetMessages): CockpitKpi;
+/**
+ * "Pipeline executions 24 h", computed exactly like the Studio's Data Flows list
+ * (`countPipelineExecutions` per data flow, the hourly histogram per flow anchored on the newest
+ * statistics update, AB#5583), then summed over the flows — so the cockpit and the list agree.
+ * Texts from `messages` (English by default, AB#5622).
+ */
+declare function executionKpi(flows: CockpitDataFlowRow[], totalCount?: number, messages?: CockpitWidgetMessages): CockpitKpi;
+/**
+ * "CK model state": models available of all installed models. ResolveFailed is an error (the
+ * data is intact, but the types are not served), importing is shown as progress. Texts from
+ * `messages` (English by default, AB#5622).
+ */
+declare function ckModelKpi(counts: CockpitCkModelCounts, messages?: CockpitWidgetMessages): CockpitKpi;
+/**
+ * "Tenants" (system cockpit, AB#5558): child tenants of the current tenant — on the system tenant
+ * every tenant of the installation. The tenant list has no state, so the tile counts only.
+ */
+declare function tenantCountKpi(tenants: CockpitChildTenants, messages?: CockpitWidgetMessages): CockpitKpi;
+/**
+ * "Blueprint updates" (system cockpit, AB#5558): installed blueprints with a newer catalog
+ * version. Only blueprints the tenant installed count as updates to act on (warning);
+ * service-managed ones (`System.*`) are applied by their service and only named in the detail.
+ */
+declare function blueprintUpdatesKpi(status: CockpitBlueprintStatus, messages?: CockpitWidgetMessages): CockpitKpi;
+/** The display word of a service health state (`degraded`, `unhealthy`, `not reachable`). */
+declare function serviceStateText(state: CockpitServiceHealthStatus, messages?: CockpitWidgetMessages): string;
+/**
+ * "Services healthy" (system cockpit, AB#5558): platform services whose health check reports
+ * Healthy, of all checked. Unhealthy and not answering are errors, degraded a warning; the tile
+ * opens the health details of the first service with a problem (else Identity).
+ */
+declare function servicesHealthKpi(services: CockpitServiceHealth[], messages?: CockpitWidgetMessages): CockpitKpi;
+/** "Version" (system cockpit, AB#5558): the host's versions; the first is the value. No page behind it. */
+declare function versionKpi(entries: CockpitVersionEntry[], messages?: CockpitWidgetMessages): CockpitKpi;
+/** SVG paths of a sparkline in a `width` × `height` box (line, filled area, last point). */
+interface SparklineGeometry {
+    line: string;
+    area: string;
+    lastX: number;
+    lastY: number;
+}
+/** Scales the values to the box; the tallest value touches the top padding. */
+declare function sparklineGeometry(values: number[], width?: number, height?: number, padding?: number): SparklineGeometry | null;
+
+/**
+ * CK model counts per state (`cockpitCkModelStates`, one request with aliased counts), shared for
+ * a few seconds per tenant between the "CK model state" KPI and the ResolveFailed provider of the
+ * attention list.
+ */
+declare class CockpitCkModelStatesService {
+    private readonly gql;
+    private readonly shared;
+    counts(tenantId: string, now?: number): Observable<CockpitCkModelCounts>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitCkModelStatesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitCkModelStatesService>;
+}
+
+/** What a tile shows when its query failed (details are logged, never shown). */
+declare const KPI_ERROR_TEXT = "The figure could not be loaded.";
+/**
+ * The cockpit KPIs. The last four are the system cockpit's (AB#5558): child tenants, blueprint
+ * updates, platform service health and the host's version.
+ */
+type CockpitKpiKind = 'adapterStatus' | 'ckModelState' | 'pipelineExecutions' | 'tenantCount' | 'blueprintUpdates' | 'servicesHealth' | 'versionInfo';
+/** State of one KPI widget. */
+type CockpitKpiResult = {
+    state: 'loading';
+}
+/**
+ * The viewer lacks a role or the tenant a CK model. `reason` says which — meant for builders
+ * only; `forBuilder: false` means the viewer is no builder and must see a neutral state.
+ */
+ | {
+    state: 'unavailable';
+    reason: string;
+    forBuilder: boolean;
+} | {
+    state: 'error';
+    message: string;
+} | {
+    state: 'ready';
+    kpi: CockpitKpi;
+};
+interface KpiGate {
+    roles: string[];
+    models: string[];
+    /** English reason (the default of {@link reasonMessage}). */
+    reason: string;
+    /** Message member of the reason (AB#5622). */
+    reasonMessage: 'kpiNeedsCommunication' | 'kpiNeedsAdminPanel' | 'kpiNeedsTenantManagement' | 'notAvailable';
+}
+/** What each KPI needs — the same as the page its tile opens. */
+declare const COCKPIT_KPI_GATES: Record<CockpitKpiKind, KpiGate>;
+/**
+ * The cockpit KPIs (AB#5558, from the Home KPI strip of AB#5545): each KPI has its own gate and
+ * query; a viewer without the gate gets `unavailable` and no request is sent.
+ */
+declare class CockpitKpiService {
+    private readonly context;
+    private readonly adapterStates;
+    private readonly ckModelStates;
+    private readonly dataFlowExecutions;
+    /** The system cockpit's data services are resolved on first use, so hosts without them need no providers. */
+    private readonly injector;
+    private readonly versions;
+    private readonly messagesSource;
+    /**
+     * The KPI's state. Texts (label, status, detail, reasons) come from `messages`, else from the
+     * host's `COCKPIT_WIDGET_MESSAGES`, else English (AB#5622).
+     */
+    kpi(kind: CockpitKpiKind, messages?: CockpitWidgetMessages): Observable<CockpitKpiResult>;
+    private resolve;
+    private load;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitKpiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CockpitKpiService>;
+}
+
+/** Findings shown before "and N more" when the config sets none. */
+declare const DEFAULT_ATTENTION_MAX_ITEMS = 6;
+/** A finding link resolved for `routerLink` + `queryParams`. */
+interface AttentionLinkView {
+    label: string;
+    path: string | string[];
+    queryParams: CockpitLinkQueryParams | null;
+}
+/** A finding with its links resolved to host URLs (unresolvable links are left out). */
+interface AttentionFindingView {
+    finding: AttentionFinding;
+    severityLabel: string;
+    /** Formatted `finding.count`, or null when the finding has none. */
+    count: string | null;
+    countLabel: string | null;
+    links: AttentionLinkView[];
+    explain: CockpitExplainTarget | null;
+}
+/**
+ * "Attention list" cockpit widget (AB#5558): rule-based health findings from the configured
+ * providers, errors first. Each provider runs only when the viewer may open what it links to, so
+ * a viewer never sees findings about objects outside their roles; with no visible provider the
+ * widget says so instead of claiming "all clear".
+ */
+declare class AttentionListWidgetComponent implements DashboardWidget<AttentionListWidgetConfig, AttentionFinding[]>, OnInit, OnChanges, OnDestroy {
+    private readonly attention;
+    private readonly context;
+    private readonly boardState;
+    config: AttentionListWidgetConfig;
+    /**
+     * Translated texts for a widget used on its own (AB#5622); wins over `COCKPIT_WIDGET_MESSAGES`.
+     * Missing members keep the English default.
+     */
+    readonly messages: _angular_core.InputSignal<Partial<CockpitWidgetMessages> | null | undefined>;
+    /** Resolved texts: defaults < host token < `messages` input. */
+    protected readonly texts: _angular_core.Signal<CockpitWidgetMessages>;
+    /**
+     * Unconstrained wrapper of the content: its height is reported so the phone tier grows the
+     * tile to fit the stacked cards instead of clipping them (AB#5558).
+     */
+    private readonly content;
+    /** Builders see why no check runs; other viewers a neutral text and the widget collapses. */
+    protected readonly isBuilder: _angular_core.WritableSignal<boolean>;
+    private readonly _state;
+    /** Message member of the current error, so the text follows a language switch (AB#5622). */
+    private readonly _error;
+    private readonly tenantId;
+    private subscription;
+    private loadToken;
+    readonly state: _angular_core.Signal<AttentionState | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<AttentionFinding[] | null>;
+    /** Findings with resolved links. */
+    readonly views: _angular_core.Signal<AttentionFindingView[]>;
+    private readonly maxItems;
+    readonly shown: _angular_core.Signal<AttentionFindingView[]>;
+    readonly hiddenCount: _angular_core.Signal<number>;
+    /**
+     * True while the widget shows a single status message instead of findings (loading, error,
+     * no visible check, all clear); the message is then centred in the tile (AB#5622).
+     */
+    protected readonly messageOnly: _angular_core.Signal<boolean>;
+    protected readonly moreText: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    protected explain(target: CockpitExplainTarget): void;
+    private resolveLinks;
+    private load;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AttentionListWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AttentionListWidgetComponent, "mm-attention-list-widget", never, { "config": { "alias": "config"; "required": false; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Result of the attention list config dialog. */
+interface AttentionListConfigResult extends WidgetConfigResult {
+    /** Empty = every registered check, including checks added later. */
+    providerIds: string[];
+    maxItems: number;
+    showExplain: boolean;
+}
+/**
+ * Config dialog of the "Attention list" widget (AB#5558): which health checks run (all, or a
+ * selection of the registered providers), how many findings are shown and whether "✦ Explain"
+ * appears. Each check still runs only for viewers with its roles.
+ */
+declare class AttentionListConfigDialogComponent implements OnInit {
+    private readonly windowRef;
+    private readonly attention;
+    initialProviderIds?: string[];
+    initialMaxItems?: number;
+    initialShowExplain?: boolean;
+    providers: AttentionProviderInfo[];
+    mode: 'all' | 'selected';
+    selection: Set<string>;
+    maxItems: number;
+    showExplain: boolean;
+    ngOnInit(): void;
+    get canSave(): boolean;
+    isSelected(id: string): boolean;
+    toggle(id: string): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AttentionListConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AttentionListConfigDialogComponent, "mm-attention-list-config-dialog", never, { "initialProviderIds": { "alias": "initialProviderIds"; "required": false; }; "initialMaxItems": { "alias": "initialMaxItems"; "required": false; }; "initialShowExplain": { "alias": "initialShowExplain"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The cockpit KPI widgets (AB#5558): "Adapter status", "CK model state" and "Pipeline executions
+ * 24 h" — one component, the KPI follows the widget type. Value, status chip (dot + label), an
+ * optional detail line and, for executions, an hourly sparkline whose `aria-label` names peak,
+ * total and failures. The tile links to the page behind the figure when the host resolves one.
+ * A viewer without the KPI's role / CK model sees why instead of an empty tile.
+ */
+declare class CockpitKpiWidgetComponent implements DashboardWidget<CockpitKpiWidgetConfig, CockpitKpi>, OnInit, OnChanges, OnDestroy {
+    private readonly kpiService;
+    private readonly context;
+    private readonly boardState;
+    config: CockpitKpiWidgetConfig;
+    /**
+     * Translated texts for a widget used on its own (AB#5622); wins over `COCKPIT_WIDGET_MESSAGES`.
+     * Missing members keep the English default.
+     */
+    readonly messages: _angular_core.InputSignal<Partial<CockpitWidgetMessages> | null | undefined>;
+    /** Resolved texts: defaults < host token < `messages` input. */
+    protected readonly texts: _angular_core.Signal<CockpitWidgetMessages>;
+    private initialised;
+    /** Texts of the last load, so the first effect run does not load twice. */
+    private loadedTexts;
+    private readonly _result;
+    private readonly tenantId;
+    private readonly options;
+    private subscription;
+    /** Set once a load has been running for {@link COCKPIT_KPI_SLOW_LOADING_MS}. */
+    private readonly slowLoading;
+    private slowTimer;
+    private readonly kind;
+    readonly result: _angular_core.Signal<CockpitKpiResult>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly data: _angular_core.Signal<CockpitKpi | null>;
+    readonly error: _angular_core.Signal<string | null>;
+    protected readonly kpi: _angular_core.Signal<CockpitKpi | null>;
+    /** "Loading…", or what a slow KPI is doing (blueprint catalog scan) after a second. */
+    protected readonly loadingText: _angular_core.Signal<string>;
+    protected readonly showDetail: _angular_core.Signal<boolean>;
+    /** Role requirements only for builders; other viewers get a neutral "Not available" (AB#5558 review). */
+    protected readonly reason: _angular_core.Signal<string>;
+    protected readonly spark: _angular_core.Signal<_meshmakers_octo_meshboard.SparklineGeometry | null>;
+    protected readonly url: _angular_core.Signal<_meshmakers_octo_meshboard.CockpitResolvedLink | null>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    private load;
+    private clearSlowTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitKpiWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CockpitKpiWidgetComponent, "mm-cockpit-kpi-widget", never, { "config": { "alias": "config"; "required": false; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * After this long still loading, a slow KPI says what it is doing instead of "Loading…"
+ * (AB#5622: the "Blueprint updates" tile scans every catalog, which can take several seconds).
+ */
+declare const COCKPIT_KPI_SLOW_LOADING_MS = 1000;
+/** What viewers without builder roles see instead of role requirements. */
+declare const NOT_AVAILABLE_TEXT = "Not available";
+/** The KPI a cockpit KPI widget shows. */
+declare function kpiKindOf(config: CockpitKpiWidgetConfig | undefined): CockpitKpiKind;
+
+/** Result of the cockpit KPI config dialog. */
+interface CockpitKpiConfigResult extends WidgetConfigResult {
+    showDetail: boolean;
+    /** Only meaningful for "Pipeline executions 24 h". */
+    showSparkline: boolean;
+}
+/**
+ * Config dialog of the cockpit KPI widgets (AB#5558). The figures themselves are fixed (they use
+ * the same rules as the pages they link to); the dialog only chooses what the tile shows. The
+ * title is edited in the widget's general settings like for every widget.
+ */
+declare class CockpitKpiConfigDialogComponent implements OnInit {
+    private readonly windowRef;
+    initialShowDetail?: boolean;
+    initialShowSparkline?: boolean;
+    supportsSparkline: boolean;
+    description?: string;
+    showDetail: boolean;
+    showSparkline: boolean;
+    ngOnInit(): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CockpitKpiConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CockpitKpiConfigDialogComponent, "mm-cockpit-kpi-config-dialog", never, { "initialShowDetail": { "alias": "initialShowDetail"; "required": false; }; "initialShowSparkline": { "alias": "initialShowSparkline"; "required": false; }; "supportsSparkline": { "alias": "supportsSparkline"; "required": false; }; "description": { "alias": "description"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Rows shown when the config sets none (the former Home panel showed eight). */
+declare const DEFAULT_RECENT_ITEMS_MAX = 8;
+/** Upper bound of the config dialog. */
+declare const MAX_RECENT_ITEMS = 20;
+/**
+ * "just now", "12 min ago", "3 h ago", "yesterday", "4 days ago" (the Cmd+K palette's wording);
+ * translated through `messages` (AB#5622).
+ */
+declare function recentRelativeTime(timestamp: number, now: number, messages?: Pick<CockpitWidgetMessages, 'recentJustNow' | 'recentMinutesAgo' | 'recentHoursAgo' | 'recentYesterday' | 'recentDaysAgo'>): string;
+/** A row with its glyph and time texts. */
+interface RecentItemView {
+    item: CockpitRecentItem;
+    glyph: string;
+    when: string;
+    datetime: string;
+    absolute: string;
+}
+/**
+ * "Recent items" cockpit widget (AB#5558): the viewer's recently opened pages, entities and
+ * boards as a list of real links, most recent first. The data is per user and comes from the
+ * host (`COCKPIT_RECENT_ITEMS`), which also re-checks visibility and decides how an entry opens
+ * (the Refinery Studio switches the mode first when needed). Without a host source the widget
+ * says "Not available" and collapses outside edit mode.
+ */
+declare class RecentItemsWidgetComponent implements DashboardWidget<RecentItemsWidgetConfig, CockpitRecentItem[]>, OnInit, OnChanges {
+    protected readonly source: _meshmakers_octo_meshboard.CockpitRecentItemsSource | null;
+    private readonly boardState;
+    config: RecentItemsWidgetConfig;
+    /**
+     * Translated texts for a widget used on its own (AB#5622); wins over `COCKPIT_WIDGET_MESSAGES`.
+     * Missing members keep the English default.
+     */
+    readonly messages: _angular_core.InputSignal<Partial<CockpitWidgetMessages> | null | undefined>;
+    /** Resolved texts: defaults < host token < `messages` input. */
+    protected readonly texts: _angular_core.Signal<CockpitWidgetMessages>;
+    /** Unconstrained content wrapper; its height lets the phone tier grow the tile (AB#5558). */
+    private readonly content;
+    private readonly _items;
+    private readonly _error;
+    /** Ticks every minute so "12 min ago" stays true while the board is open. */
+    private readonly now;
+    private loadToken;
+    private initialised;
+    /** History revision of the last load, so the first effect run does not load twice. */
+    private loadedRevision;
+    readonly data: _angular_core.Signal<CockpitRecentItem[] | null>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    protected readonly views: _angular_core.Signal<RecentItemView[] | null>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    /** Rows shown: the configured count within 1…20. */
+    protected maxItems(): number;
+    /** A plain left click opens in the app through the host; modified clicks are left to the browser. */
+    protected open(item: CockpitRecentItem, event: MouseEvent): void;
+    protected openPalette(): void;
+    private load;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecentItemsWidgetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RecentItemsWidgetComponent, "mm-recent-items-widget", never, { "config": { "alias": "config"; "required": false; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Result of the "Recent items" config dialog. */
+interface RecentItemsConfigResult extends WidgetConfigResult {
+    maxItems: number;
+}
+/**
+ * Config dialog of the "Recent items" widget (AB#5558). The entries are personal (every viewer
+ * sees their own history), so the board only stores how many rows are shown.
+ */
+declare class RecentItemsConfigDialogComponent implements OnInit {
+    private readonly windowRef;
+    initialMaxItems?: number;
+    readonly maxLimit = 20;
+    maxItems: number;
+    ngOnInit(): void;
+    onSave(): void;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecentItemsConfigDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RecentItemsConfigDialogComponent, "mm-recent-items-config-dialog", never, { "initialMaxItems": { "alias": "initialMaxItems"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** The library's attention providers, in display order (errors of the platform first). */
+declare const BUILT_IN_ATTENTION_PROVIDERS: readonly Type<AttentionProvider>[];
+/**
+ * Registers the cockpit widgets (AB#5558): "Attention list", "Adapter status", "CK model state",
+ * "Pipeline executions 24 h", the system cockpit's "Tenants", "Blueprint updates", "Services
+ * healthy" and "Version", and "Recent items". Persisted with `dataSourceType: 'static'` and a small JSON
+ * config (see the README widget catalogue for the exact keys).
+ */
+declare function registerCockpitWidgets(registry: WidgetRegistryService): void;
+/**
+ * Registers the cockpit widgets and the library's attention providers. Call it next to
+ * `provideMeshBoard()`; provide the host services with `provideCockpitWidgetHost()` and add host
+ * checks as `{ provide: COCKPIT_ATTENTION_PROVIDERS, useClass: …, multi: true }`.
+ */
+declare function provideCockpitWidgets(): EnvironmentProviders;
+
+/**
+ * THE adapter online rule (AB#5545, moved here with the cockpit widgets in AB#5558). One definition
+ * for the "Adapter status" cockpit widget and the adapters provider of the "Attention list", and —
+ * re-exported by the Refinery Studio — for Integration › Overview, the pool detail page and the
+ * adapter detail header:
+ *
+ * - **Online** — the adapter is connected right now: `communicationState === ONLINE`. Errors do not
+ *   change this (a connected adapter with a configuration error is online *and* in error).
+ * - **Expected to run** — the denominator of every "x / y online" counter: adapters the operator
+ *   was asked to run (`deploymentState` `DEPLOYED`, `PENDING` or `ERROR` — a failed deployment is
+ *   still supposed to run, it is counted as offline *and* reported as an error), every adapter
+ *   online right now (edge / locally run adapters have no Helm deployment), and registered adapters without a Helm chart (`DISABLED` and not
+ *   `UNREGISTERED` — run outside the operator, e.g. on an edge device). Undeployed Helm adapters
+ *   and adapters that never connected are not expected to run, so they never count as "offline".
+ *
+ * Every online adapter is expected to run, so `online ≤ expected` always holds. On-demand adapters
+ * at rest (hibernated, draining, waking) are expected to run but offline on purpose; counters show
+ * them separately (`resting`) and do not warn about them.
+ *
+ * States are compared as GraphQL enum values, case-insensitively, so both the generated `*Dto`
+ * enums (`'ONLINE'`) and plain strings work.
+ */
+interface AdapterOnlineFields {
+    communicationState?: string | null;
+    deploymentState?: string | null;
+    lifecycleState?: string | null;
+}
+declare function isAdapterOnline(adapter: AdapterOnlineFields): boolean;
+declare function isAdapterExpectedToRun(adapter: AdapterOnlineFields): boolean;
+/**
+ * Hibernated, draining or waking on-demand adapters are offline on purpose (AB#4919). Only a
+ * known non-running lifecycle state counts; a missing lifecycle state is not "at rest".
+ */
+declare function isAdapterAtRest(adapter: AdapterOnlineFields): boolean;
+interface AdapterOnlineSummary {
+    /** Adapters connected right now. */
+    online: number;
+    /** Adapters expected to run (the denominator). */
+    expected: number;
+    /** All adapters given. */
+    total: number;
+    /** Expected to run, offline, and at rest on purpose (on-demand). */
+    resting: number;
+    /** Expected to run, offline, and not at rest — these need attention. */
+    offline: number;
+}
+declare function summarizeAdapterOnline(adapters: readonly AdapterOnlineFields[]): AdapterOnlineSummary;
+
+/**
+ * Pipeline execution counting shared by the cockpit widgets (AB#5558) and the
+ * Refinery Studio (Data Flows list, data flow editor, adapter / data flow
+ * detail pages): the 24 h hourly histogram behind every execution sparkline
+ * and the execution counts over a set of pipelines. One implementation, so the
+ * cockpit's "Pipeline executions 24 h" and the Data Flows list agree.
+ */
+/** One hour slot of the 24h execution histogram rendered by the sparkline. */
+interface HourlyExecutionBucket {
+    /** UTC epoch ms of the hour start (aligned to the clock hour). */
+    hourStart: number;
+    ok: number;
+    fail: number;
+}
+/** Raw server-side folded hour bucket (PipelineStatistics.HourlyBuckets, AB#4370). */
+interface RawHourBucket {
+    hourStartAt?: string | Date | null;
+    successCount?: number | null;
+    failureCount?: number | null;
+}
+/** Number of hourly slots the sparkline renders. */
+declare const HISTOGRAM_HOURS = 24;
+declare const HOUR_MS: number;
+declare const DAY_MS: number;
+/** Options of {@link buildHourlyHistogram}. */
+interface HourlyHistogramOptions {
+    /**
+     * The statistics' `lastUpdatedAt` (for several pipelines the newest, see
+     * {@link latestStatisticsUpdate}). The backend's windows are the clock hours ending with the
+     * hour of its last sweep (AB#5583); when the browser clock is already in the next hour (or,
+     * with clock skew, still in the previous one) the bars follow the statistics, so the 24 bars
+     * sum to `last24Hours*`. Ignored when missing, invalid or more than an hour away from now
+     * (stale statistics: the browser clock keeps the time axis honest).
+     */
+    anchor?: string | Date | number | null;
+    /** "Now" in epoch ms (tests). */
+    now?: number;
+}
+/**
+ * Builds 24 contiguous hourly slots ending at the current clock hour from a flat
+ * list of raw server buckets. Sparse backend buckets (only hours with executions
+ * are stored) are gap-filled with zeros so the sparkline renders a continuous
+ * time axis. Buckets outside the visible 24h window are ignored.
+ *
+ * Since AB#5583 the buckets hold every counted execution (folded and still
+ * retained), so nothing is added to the current bar any more: seeding it with the
+ * rolling last-hour counts double-counted the previous hour's tail. The legacy
+ * numeric seed arguments are accepted for compatibility and ignored.
+ */
+declare function buildHourlyHistogram(rawBuckets: (RawHourBucket | null)[] | null | undefined, options?: HourlyHistogramOptions | number, _legacySeedFail?: number): HourlyExecutionBucket[];
+/** The newest `lastUpdatedAt` of several statistics (the anchor of a summed histogram), or null. */
+declare function latestStatisticsUpdate(statistics: ({
+    lastUpdatedAt?: string | Date | null;
+} | null | undefined)[]): Date | null;
+/** Folded `PipelineStatistics` of one pipeline (AB#4370), as selected by the queries. */
+interface PipelineStatisticsInput {
+    lastExecutionAt?: string | Date | null;
+    /** When the backend last recomputed the statistics (its windows end with this hour, AB#5583). */
+    lastUpdatedAt?: string | Date | null;
+    lastHourSuccessCount?: number | null;
+    lastHourFailureCount?: number | null;
+    last24HoursSuccessCount?: number | null;
+    last24HoursFailureCount?: number | null;
+    lastHourAvgDurationMs?: number | null;
+    last24HoursAvgDurationMs?: number | null;
+    hourlyBuckets?: (RawHourBucket | null)[] | null;
+}
+/** The latest execution of one pipeline. */
+interface LatestExecutionInput {
+    startedAt?: string | Date | null;
+    status?: string | null;
+}
+/** One pipeline: its statistics and latest execution, both optional. */
+interface PipelineExecutionInput {
+    statistics?: PipelineStatisticsInput | null;
+    latestExecution?: LatestExecutionInput | null;
+}
+/** Execution counts summed over pipelines. */
+interface PipelineExecutionCounts {
+    success24h: number;
+    failure24h: number;
+    success1h: number;
+    failure1h: number;
+    /** Most recent execution start over all pipelines. */
+    latestExecution: Date | null;
+    /** False when no pipeline had statistics or an execution. */
+    hasData: boolean;
+}
+/** Reads statistics and latest execution from data-flow child pipelines (non-pipelines yield empty inputs). */
+declare function pipelineExecutionInputs(children: (unknown | null)[] | null | undefined): PipelineExecutionInput[];
+/**
+ * The Data Flows list's execution counting, shared with the cockpit (AB#5545 / AB#5558) so both
+ * show the same numbers: the statistics are the baseline, and a latest execution the statistics
+ * cannot contain yet is counted in for immediate feedback (COMPLETED → success, FAILED → failure).
+ * "Cannot contain yet" = started after the statistics' `lastUpdatedAt` (the backend's totals
+ * include every execution it saw at that sweep, AB#5583) and after `lastExecutionAt`; without
+ * `lastUpdatedAt` (older backends / queries) only `lastExecutionAt` is compared, as before.
+ */
+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, 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, 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, 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 };