@meshmakers/shared-ui 3.4.1480 → 3.5.0

package/types/meshmakers-shared-ui-shell.d.ts

@@ -0,0 +1,939 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { ActivatedRouteSnapshot } from '@angular/router';
+import { DrawerItem } from '@progress/kendo-angular-layout';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+import { Observable } from 'rxjs';
+import { BreadCrumbData } from '@meshmakers/shared-services';
+import { NotificationDisplayOptions } from '@meshmakers/shared-ui';
+
+/**
+ * UI strings of the shell building blocks (`mm-shell-rail`, `mm-space-shell`,
+ * `mm-settings-side-nav`, `mm-shell-top-bar`, `mm-shell-user-menu`) and of the
+ * pure helpers (greeting, environment chip).
+ *
+ * Hosts translate them in two ways, which can be combined:
+ * - app wide: `{ provide: SHELL_MESSAGES, useValue: { signIn: 'Anmelden', … } }`;
+ * - per component: the `messages` input (wins over the token).
+ *
+ * Missing, `undefined` or `null` members keep the English default of
+ * {@link DEFAULT_SHELL_MESSAGES}. Strings with `{name}` placeholders are filled with
+ * {@link formatShellMessage}.
+ */
+interface ShellMessages {
+    /** Screen-reader text after an external link marker (↗). */
+    opensInNewTab: string;
+    /** `aria-label` of the rail navigation. */
+    railLabel: string;
+    /** Accessible text of a navigation badge without its own label; `{count}` = the count. */
+    navBadge: string;
+    /** `aria-label` of a rail icon with a badge; `{label}` = area name, `{badge}` = badge text. */
+    navItemWithBadge: string;
+    /** `aria-label` of the back link on object detail pages; `{target}` = list name. */
+    backTo: string;
+    /** `aria-label` of the status chip list. */
+    statusChips: string;
+    /** `aria-label` of the tab strip; `{area}` = area name. */
+    areaPages: string;
+    /** `aria-label` of the side navigation; `{area}` = area name. */
+    areaCategories: string;
+    /** The "home" entry of the side navigation; `{area}` = area name as given (not re-cased, AB#5621). */
+    allOfArea: string;
+    /** `aria-label` of the mode switch group. */
+    modeSwitch: string;
+    /** `aria-label` of the search trigger. */
+    searchAriaLabel: string;
+    /** Visible text of the search trigger. */
+    search: string;
+    /** Visible text of the assistant toggle. */
+    assistant: string;
+    signIn: string;
+    signOut: string;
+    /** Title (`aria-label`) of the account panel. */
+    accountAndPreferences: string;
+    /** `aria-label` of the avatar button for a known user; `{name}` = display name. */
+    accountAndPreferencesOf: string;
+    theme: string;
+    themeSystem: string;
+    themeLight: string;
+    themeDark: string;
+    density: string;
+    language: string;
+    manageProfile: string;
+    /** Version line; `{version}` = version string. */
+    version: string;
+    environmentProduction: string;
+    environmentProductionShort: string;
+    environmentStaging: string;
+    environmentStagingShort: string;
+    environmentDevelopment: string;
+    environmentDevelopmentShort: string;
+    environmentTesting: string;
+    environmentTestingShort: string;
+    environmentUnknown: string;
+    environmentUnknownShort: string;
+    greetingMorning: string;
+    greetingAfternoon: string;
+    greetingEvening: string;
+    /** Greeting with a name; `{greeting}` = phrase, `{name}` = first name. */
+    greetingWithName: string;
+    /** Meta line label of the tenant. */
+    tenant: string;
+}
+/** English defaults of {@link ShellMessages}. */
+declare const DEFAULT_SHELL_MESSAGES: ShellMessages;
+/**
+ * App-wide translations of the shell. Partial: members left out keep their English default.
+ */
+declare const SHELL_MESSAGES: InjectionToken<Partial<ShellMessages>>;
+/**
+ * Merges message overrides over {@link DEFAULT_SHELL_MESSAGES}, later sources winning.
+ * Members that are missing, `undefined` or `null` keep the earlier value, so a host compiled
+ * against an older `ShellMessages` shape never renders an empty label.
+ */
+declare function resolveShellMessages(...overrides: (Partial<ShellMessages> | null | undefined)[]): ShellMessages;
+/** Replaces `{name}` placeholders; unknown placeholders stay as they are. */
+declare function formatShellMessage(message: string, values: Record<string, string | number>): string;
+
+/** Id of the separator in front of the rail's bottom block (Settings). */
+declare const RAIL_BOTTOM_SEPARATOR_ID = "rail-bottom";
+declare function areaId(space: string): string;
+/** The space of an area id (`area-data` → `data`), or null for any other id. */
+declare function spaceOfAreaId(id: string): string | null;
+declare function tabId(space: string, tab: string): string;
+/**
+ * The space whose pages use the settings side navigation (`mm-settings-side-nav`) instead
+ * of the tab strip. Default `'settings'` (area id `area-settings`); provide `null` for a
+ * host without a settings space.
+ */
+declare const SHELL_SETTINGS_SPACE: InjectionToken<string | null>;
+
+/**
+ * One entry of the shell navigation: a rail area, a tab, or an entry nested
+ * below a tab (flyout only). Built from the CommandService's visible items.
+ */
+interface ShellNavNode {
+    id: string;
+    text: string;
+    svgIcon?: SVGIcon;
+    tooltip?: string;
+    separator: boolean;
+    /** The CommandService highlights exactly this entry (longest link match on the URL). */
+    selected: boolean;
+    /** This entry or one below it is selected. */
+    active: boolean;
+    /** Opening it navigates (router link or external href); otherwise it only groups entries. */
+    navigable: boolean;
+    /** Opens in a new browser tab. */
+    external: boolean;
+    children: ShellNavNode[];
+    /**
+     * Optional count shown as a badge on the rail icon / flyout entry (AB#5621); 0 or none shows
+     * nothing. The rail's `badges` input wins over it. Not set by {@link ShellNavigationService}.
+     */
+    badgeCount?: number;
+}
+/** `space` / `tab` / `objectDetail` route data, merged from the root to the deepest active route. */
+interface ShellRouteData {
+    space?: string;
+    tab?: string;
+    /**
+     * The page is the detail page of one object (AB#5547): its own object header (name, chips,
+     * actions, object tabs) replaces the area title and tab strip of the space header. Set by
+     * `data: { objectDetail: true }` on any route of the chain.
+     */
+    objectDetail?: boolean;
+    /**
+     * `data: { spaceTabs: false }`: the page brings its own navigation for the area's entries, so
+     * the space header leaves its tab strip out instead of showing the same entries twice.
+     * (Settings needs no flag: its side navigation replaces the tab strip on every page.)
+     */
+    spaceTabs?: boolean;
+}
+/** Navigation traits of one command item, keyed by id (see {@link ShellNavigationService.buildTree}). */
+interface ShellNavItemKind {
+    navigable: boolean;
+    external: boolean;
+    tooltip?: string;
+}
+/**
+ * The shell's view of the navigation: turns the flat, visibility-filtered
+ * item list of the CommandService into a tree (rail areas → tabs → nested
+ * entries) and works out which area and tab are active.
+ *
+ * The active area comes from the route's `data.space` when it names an area
+ * of the current mode, otherwise from the area that holds the selected
+ * entry. The active tab likewise comes from `data.tab` (matched as
+ * `<space>-<tab>`) or from the selection. URLs never change for the shell.
+ */
+declare class ShellNavigationService {
+    private readonly commandService;
+    private readonly commandSettings;
+    private readonly router;
+    private readonly settingsSpace;
+    private readonly items;
+    private readonly _routeData;
+    readonly routeData: _angular_core.Signal<ShellRouteData>;
+    private readonly tree;
+    /** Rail areas above the bottom separator. */
+    readonly topAreas: _angular_core.Signal<ShellNavNode[]>;
+    /** Rail areas pinned to the bottom (Settings). */
+    readonly bottomAreas: _angular_core.Signal<ShellNavNode[]>;
+    readonly activeArea: _angular_core.Signal<ShellNavNode | null>;
+    readonly activeTab: _angular_core.Signal<ShellNavNode | null>;
+    /**
+     * Settings has one navigation (concept §5.6, AB#5523; the space comes from {@link SHELL_SETTINGS_SPACE}): the category list on the left of every
+     * Settings page, never the tab strip — so opening a category cannot switch between two layouts.
+     * Off on object detail pages, whose object header owns the navigation.
+     */
+    readonly settingsSideNav: _angular_core.Signal<boolean>;
+    /** The Settings home is open: Settings side navigation without an active category. */
+    readonly settingsHomeActive: _angular_core.Signal<boolean>;
+    /**
+     * Whether the space header shows the area's tab strip: not in Settings (side navigation), not
+     * when the route says `spaceTabs: false`; default true.
+     */
+    readonly showTabs: _angular_core.Signal<boolean>;
+    /** The current page is an object detail page (route data `objectDetail`). */
+    readonly objectDetail: _angular_core.Signal<boolean>;
+    /**
+     * Where "back" leads from an object detail page: the selected entry of the active area
+     * (the list the object belongs to, e.g. Integration › Adapters), else the active tab.
+     */
+    readonly backTarget: _angular_core.Signal<ShellNavNode | null>;
+    constructor();
+    /**
+     * Opens an entry: navigable entries navigate (or open their href), grouping
+     * entries open their first navigable descendant.
+     */
+    open(node: ShellNavNode): Promise<void>;
+    /**
+     * Opens an area from the rail. An area with its own in-app link (e.g. Home without tabs, or a
+     * Settings overview) opens that page (AB#5621); any other area opens its first page. Nothing
+     * happens when the current page already lives in the area (re-clicking the active area must
+     * not throw the person out of the page they are on). External entries are skipped; an area
+     * click never pops up a browser tab.
+     */
+    openArea(area: ShellNavNode): Promise<void>;
+    /** Opens the first page of the first area (used after a mode switch). */
+    openFirstPage(): Promise<void>;
+    /**
+     * Where a rail click on an area leads: the area itself when it has its own in-app link,
+     * else its first navigable, in-app entry; `null` when there is none.
+     */
+    static areaTarget(area: ShellNavNode): ShellNavNode | null;
+    /** The selected entry at or below a node, deepest first; `null` when none is selected. */
+    static deepestSelected(node: ShellNavNode): ShellNavNode | null;
+    /** The first navigable, in-app entry below a node (depth first). */
+    static firstPage(node: ShellNavNode, allowExternal: boolean): ShellNavNode | null;
+    /**
+     * Link / href / target per item id, read from the command item tree. The
+     * CommandService's items carry neither, but the rail must know whether an
+     * entry navigates and whether it leaves the app.
+     */
+    private collectKinds;
+    static buildTree(items: DrawerItem[], kinds: Map<string, ShellNavItemKind>): {
+        top: ShellNavNode[];
+        bottom: ShellNavNode[];
+    };
+    /** Drops leading, trailing and repeated separators (left over when entries around them are hidden). */
+    static tidySeparators(nodes: ShellNavNode[]): ShellNavNode[];
+    static readRouteData(root: ActivatedRouteSnapshot | null | undefined): ShellRouteData;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellNavigationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShellNavigationService>;
+}
+
+/**
+ * A count next to a navigation entry (AB#5621): pending work such as open inbox items or ToDos.
+ * Hosts pass either the plain count or this object. A count of 0 (or none) shows no badge.
+ */
+interface ShellNavBadge {
+    count: number;
+    /** Needs attention: rendered in the warning colour. */
+    attention?: boolean;
+    /**
+     * Accessible text of the badge (e.g. "3 open ToDos"); without one the shell reads
+     * {@link ShellMessages.navBadge} (`'{count} open'`).
+     */
+    label?: string;
+}
+/** Badge input of the rail: keyed by node id (area id `area-<space>` or a tab id). */
+type ShellNavBadges = Readonly<Record<string, number | ShellNavBadge | null | undefined>>;
+/** Highest count shown as a number; larger counts read `99+`. */
+declare const SHELL_BADGE_MAX = 99;
+/**
+ * The badge of one entry: the `badges` input wins over the node's own `badgeCount`;
+ * `null` when there is nothing to show (missing, 0, negative or not a number).
+ */
+declare function resolveShellBadge(badges: ShellNavBadges | null | undefined, id: string, ownCount?: number | null): ShellNavBadge | null;
+/** Visible text of a badge count: the number, or `99+` above {@link SHELL_BADGE_MAX}. */
+declare function shellBadgeText(count: number): string;
+
+/** A status chip in the space header: dot + label, never colour alone. */
+interface SpaceStatusChip {
+    label: string;
+    status: 'success' | 'warning' | 'error' | 'info' | 'neutral';
+}
+/**
+ * Lets the page shown inside a space contribute to the space header: status
+ * chips next to the title and a template for the primary actions.
+ *
+ * A page sets them in its constructor or `ngOnInit` and never cleans up: the
+ * shell calls {@link mark} when a navigation starts and
+ * {@link clearOlderThan} when it ends with a different page component, which
+ * drops only what the previous page contributed. A cancelled navigation or a
+ * param-only change (same component) keeps the chips.
+ */
+declare class SpaceHeaderService {
+    private readonly _chips;
+    private readonly _actions;
+    private stamp;
+    private chipsStamp;
+    private actionsStamp;
+    readonly chips: _angular_core.Signal<SpaceStatusChip[]>;
+    readonly actions: _angular_core.Signal<TemplateRef<unknown> | null>;
+    setChips(chips: SpaceStatusChip[]): void;
+    setActions(actions: TemplateRef<unknown> | null): void;
+    /** A marker for "now"; contributions made after it count as newer. */
+    mark(): number;
+    /** Drops every contribution made at or before the marker. */
+    clearOlderThan(marker: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpaceHeaderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpaceHeaderService>;
+}
+
+/**
+ * Hook between the top bar's search button and the command palette (AB#5520).
+ *
+ * The shell only announces that the person asked for search; it does not
+ * know the palette. The host (or the palette) subscribes once and opens it:
+ *
+ * ```ts
+ * inject(ShellSearchTriggerService).requested$
+ *   .pipe(takeUntilDestroyed())
+ *   .subscribe(() => commandPalette.open());
+ * ```
+ *
+ * Until something subscribes, a click is a no-op. The keyboard shortcut
+ * (Cmd/Ctrl+K) is not bound here — it belongs to the palette, which can call
+ * {@link request} or open itself directly.
+ */
+declare class ShellSearchTriggerService {
+    private readonly requests;
+    /** Emits every time search was requested from the shell. */
+    readonly requested$: Observable<void>;
+    request(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellSearchTriggerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShellSearchTriggerService>;
+}
+
+/**
+ * Host-specific crumb rewriting of {@link shellBreadcrumbs}. Hosts that migrated from a
+ * section-based navigation use it to replace the old section crumb with the rail area.
+ */
+interface ShellBreadcrumbOptions {
+    /**
+     * Lower-case labels of old section crumbs that routes still start with (e.g. `'identity'`).
+     * Such a first crumb is replaced by the rail area the page lives in.
+     */
+    legacySectionCrumbs?: ReadonlySet<string>;
+    /**
+     * Area names of old section crumbs (lower-case key → area name), used when the page has no
+     * active area: `{ communication: 'Integration' }` turns "Communication › Data Flows" into
+     * "Integration › Data Flows".
+     */
+    legacySectionAreaNames?: Readonly<Record<string, string>>;
+}
+/** A breadcrumb the shell added for the rail area; clicking it opens the area. */
+interface ShellAreaCrumb extends BreadCrumbData {
+    areaId: string;
+}
+declare function isAreaCrumb(item: unknown): item is ShellAreaCrumb;
+/**
+ * Breadcrumbs as the shell shows them (AB#5516): the first crumb names the rail area of the
+ * page (route `data.space`), never a section of an old drawer navigation.
+ *
+ * - a legacy section crumb ({@link ShellBreadcrumbOptions.legacySectionCrumbs}) is replaced by the area crumb;
+ * - a first crumb that already is the area ("Settings") stays as it is;
+ * - otherwise the area crumb is put in front ("Data Explorer" → "Data › Data Explorer");
+ * - the area crumb is dropped again when the next crumb carries the same label
+ *   ("General › Settings" → "Settings", not "Settings › Settings").
+ *
+ * - crumbs without text are dropped (no empty segments).
+ *
+ * Pure: returns a new array and never mutates the items (the BreadCrumbService re-emits the
+ * same objects after resolving `{{placeholders}}`).
+ */
+declare function shellBreadcrumbs(allItems: readonly BreadCrumbData[], area: ShellNavNode | null, options?: ShellBreadcrumbOptions): BreadCrumbData[];
+/** "Integration › Adapters" — the description stored with a recent page. */
+declare function crumbPath(items: readonly BreadCrumbData[]): string | undefined;
+
+/**
+ * The Home space header (wireframe screen 1, AB#5558): instead of the area name "Home" it greets
+ * the user — "Good morning, Gerald" — with a short meta line naming the tenant. Pass the results
+ * to `mm-space-shell` as `heading` and `meta`.
+ *
+ * Every helper takes optional {@link ShellMessages} overrides (translations).
+ */
+/** A label/value pair of the space header meta line (the value is set in mono). */
+interface SpaceMetaItem {
+    label: string;
+    value: string;
+}
+/** The parts of the signed-in user the greeting reads. */
+interface GreetingUser {
+    given_name?: string | null;
+}
+/** Morning 05–11, afternoon 12–17, evening otherwise (local time of the browser). */
+declare function greetingPhrase(now: Date, messages?: Partial<ShellMessages> | null): string;
+/** The first name: the `given_name` claim, else the first word of the display name, else null. */
+declare function firstNameOf(user: GreetingUser | null | undefined, displayName: string | null | undefined): string | null;
+/** "Good morning, Gerald", or just "Good morning" when the name is unknown. */
+declare function homeGreeting(user: GreetingUser | null | undefined, displayName: string | null | undefined, now: Date, messages?: Partial<ShellMessages> | null): string;
+/** The meta line of the Home header: the tenant (nothing without one). */
+declare function homeMeta(tenantId: string | null | undefined, messages?: Partial<ShellMessages> | null): SpaceMetaItem[];
+
+/** Status colour of a chip; the label always carries the meaning as well (never colour alone). */
+type ShellStatus = 'success' | 'warning' | 'error' | 'info' | 'neutral';
+/** The environment chip next to the tenant switcher in `mm-shell-top-bar`. */
+interface ShellEnvironmentChip {
+    label: string;
+    /** Shown on narrow screens, so the environment never becomes colour-only. */
+    short: string;
+    status: ShellStatus;
+    /** Marks the whole top bar as production (accent line). */
+    production?: boolean;
+}
+/** Tenant environment modes of the OctoMesh tenant mode configuration. */
+type ShellEnvironmentMode = 'PRODUCTION' | 'STAGING' | 'DEVELOPMENT' | 'TESTING' | 'unknown';
+/**
+ * The environment chip of a tenant mode, in sentence case with its status colour:
+ * Production (error, marks the bar), Staging (warning), Development (success),
+ * Testing (info), anything else "Environment unknown" (neutral).
+ */
+declare function shellEnvironmentChip(mode: ShellEnvironmentMode | string | null | undefined, messages?: Partial<ShellMessages> | null): ShellEnvironmentChip;
+
+/**
+ * Toast stacking for a shell host (AB#5516 visual check: six identical "not found" errors
+ * covered the top bar): identical messages once; errors leave after 10 s and warnings after
+ * 8 s (paused while hovered or focused), except those with details, which wait for the user;
+ * at most three toasts, a success/info is dropped before any error. Errors that must stay
+ * pass `hideAfter: 0`.
+ *
+ * Use: `{ provide: NOTIFICATION_DISPLAY_OPTIONS, useValue: SHELL_NOTIFICATION_OPTIONS }`.
+ * Placing `.k-notification-group` below the top bar is the host's global style.
+ */
+declare const SHELL_NOTIFICATION_OPTIONS: NotificationDisplayOptions;
+
+/**
+ * The rail: one icon per area of the navigation tree, Settings pinned to the
+ * bottom. Enter/Space or a click on an icon navigates to the area. The
+ * flyout with the area's entries is a disclosure: it opens on hover or with
+ * Arrow Right (`aria-expanded` / `aria-controls` on the icon); it never opens
+ * on focus alone. On phones (≤ 640 px) the rail is a bottom bar without
+ * flyouts — the space shell's tab strip takes over.
+ *
+ * Pointer: hovering opens the flyout after a short intent delay (at once when
+ * another flyout is already showing). It stays open while the pointer is over
+ * the icon or the flyout — the flyout host spans the gap between them, so
+ * crossing it never counts as leaving — and closes only after a grace delay
+ * once the pointer has left both. A mouse click on an icon with a flyout
+ * still navigates, and additionally pins the flyout open (as does Arrow
+ * Right): a pinned flyout ignores the pointer leaving and closes on an
+ * outside click, Escape, choosing an entry, focus leaving the entry, a
+ * second click on the same icon, or a navigation (AB#5621).
+ *
+ * Navigation (AB#5621): every open flyout — pinned or hovered — closes when a
+ * router navigation ends or the active area changes, so a click on an icon
+ * that navigates does not leave the flyout over the new page. A click that
+ * does not navigate (the area's page is already open) keeps the pin. Closing
+ * on navigation moves focus only when it was inside the flyout (back to its
+ * area icon); focus the new page took is left alone.
+ *
+ * Keyboard: the rail is one tab stop (roving tabindex). Arrow Up/Down (Left/
+ * Right on the bottom bar) move between areas, Home/End jump, Arrow Right
+ * opens the flyout and focuses its first entry; inside the flyout Arrow
+ * Up/Down move, Escape or Arrow Left return to the icon. After choosing a
+ * flyout entry focus returns to the area icon instead of falling to <body>.
+ *
+ * Badges (AB#5621): `badges` maps node ids (areas and flyout entries) to a count or a
+ * {@link ShellNavBadge}; a node's own `badgeCount` is the fallback. 0 or no count shows nothing.
+ * The count joins the icon's accessible name ("Inbox, 3 open") and is read after a flyout entry.
+ *
+ * Every activation of an area icon emits `areaSelected` — also for areas without entries
+ * (Home, a Settings overview), which have no flyout; `ShellNavigationService.openArea` opens
+ * the area's own link then.
+ *
+ * Pure presentation: the host feeds the areas (`ShellNavigationService.topAreas()` /
+ * `bottomAreas()`) and handles the outputs (`openArea` / `open`).
+ */
+/** Hover intent before a flyout opens when none is showing (ms). */
+declare const RAIL_FLYOUT_OPEN_DELAY = 120;
+/** Grace period after the pointer left both icon and flyout (ms). */
+declare const RAIL_FLYOUT_CLOSE_DELAY = 300;
+declare class ShellRailComponent {
+    private readonly host;
+    private readonly changeDetector;
+    readonly areas: _angular_core.InputSignal<ShellNavNode[]>;
+    readonly bottomAreas: _angular_core.InputSignal<ShellNavNode[]>;
+    readonly activeAreaId: _angular_core.InputSignal<string | null>;
+    /** Counts per node id (area or flyout entry); wins over `ShellNavNode.badgeCount`. */
+    readonly badges: _angular_core.InputSignal<Readonly<Record<string, number | ShellNavBadge | null | undefined>>>;
+    /** Translations; members left out fall back to {@link SHELL_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<ShellMessages> | null>;
+    protected readonly m: _angular_core.Signal<ShellMessages>;
+    /** An area icon was activated. */
+    readonly areaSelected: _angular_core.OutputEmitterRef<ShellNavNode>;
+    /** An entry in a flyout was activated. */
+    readonly itemSelected: _angular_core.OutputEmitterRef<ShellNavNode>;
+    /** The area whose flyout is shown. */
+    protected readonly openId: _angular_core.WritableSignal<string | null>;
+    /** Opened by click or keyboard: the pointer leaving does not close it. */
+    protected readonly pinned: _angular_core.WritableSignal<boolean>;
+    private readonly focusedId;
+    private openTimer;
+    private closeTimer;
+    constructor();
+    private readonly allAreas;
+    /** The one area button in the tab order: the focused one, else the active one, else the first. */
+    protected readonly tabStopId: _angular_core.Signal<string>;
+    protected hasFlyout(area: ShellNavNode): boolean;
+    /** The badge of a node, or null when it shows none. */
+    protected badgeOf(node: ShellNavNode): ShellNavBadge | null;
+    protected badgeText(badge: ShellNavBadge): string;
+    /** Accessible text of a badge: its own label, else "{count} open". */
+    protected badgeLabel(badge: ShellNavBadge): string;
+    /** Accessible name of an area icon, with its badge when it has one. */
+    protected areaLabel(area: ShellNavNode): string;
+    protected flyoutId(area: ShellNavNode): string;
+    protected onAreaClick(area: ShellNavNode, event?: MouseEvent): void;
+    protected onItemClick(area: ShellNavNode, item: ShellNavNode): void;
+    protected onAreaFocus(area: ShellNavNode): void;
+    protected onPointerEnter(area: ShellNavNode): void;
+    protected onPointerLeave(area: ShellNavNode): void;
+    protected onEntryFocusOut(area: ShellNavNode, event: FocusEvent): void;
+    protected onDocumentPointerDown(event: Event): void;
+    protected onDocumentEscape(): void;
+    protected onAreaKeydown(area: ShellNavNode, event: KeyboardEvent): void;
+    protected onFlyoutKeydown(area: ShellNavNode, event: KeyboardEvent): void;
+    /** A navigation happened: close the flyout without taking focus from the new page. */
+    private closeOnNavigation;
+    private openNow;
+    private close;
+    private cancelOpen;
+    private cancelClose;
+    private clearTimers;
+    private focusArea;
+    private entryOf;
+    private flyoutItems;
+    /** Attribute lookup without building a selector from ids (no escaping needed). */
+    private findByAttribute;
+    /** Below 640 px the rail is laid out horizontally at the bottom. */
+    private isBottomBar;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellRailComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellRailComponent, "mm-shell-rail", never, { "areas": { "alias": "areas"; "required": false; "isSignal": true; }; "bottomAreas": { "alias": "bottomAreas"; "required": false; "isSignal": true; }; "activeAreaId": { "alias": "activeAreaId"; "required": false; "isSignal": true; }; "badges": { "alias": "badges"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "areaSelected": "areaSelected"; "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+interface MenuPosition {
+    top: number;
+    left: number;
+}
+/**
+ * The header of a space (concept §3.3): breadcrumbs, the area title with
+ * optional status chips and a primary-action slot, and the tab strip built
+ * from the area's children — the same entries the rail flyout lists.
+ *
+ * Content projection:
+ * - `[spaceCrumbs]` — the breadcrumb line above the title
+ * - `[spaceActions]` — primary actions, right of the title
+ *
+ * Tabs are navigation, not ARIA tabs (there is no tab panel): a `nav` with
+ * buttons and `aria-current="page"` on the active one. A grouping tab
+ * without its own page (e.g. Swagger) is a menu button: opening moves focus
+ * into the menu, Arrow Up/Down/Home/End move, Escape (on the button or in the
+ * menu) closes and returns focus to the button, Tab / focus leaving / a click
+ * outside / scrolling or resizing closes it. The menu is positioned `fixed`
+ * from the button's bounding box, so the scrollable tab strip cannot clip it.
+ * Without an area (a page outside the current mode's navigation) only the
+ * breadcrumbs and actions are shown. A `heading` replaces the area name and a `meta` line
+ * follows it (Home greets the user and names the tenant, wireframe screen 1).
+ *
+ * On an object detail page (`objectDetail`, AB#5547) the page's own object header
+ * (name, chips, actions, object tabs) replaces the area title, the status chips and
+ * the tab strip: the space header shrinks to one line with a back link to the list
+ * the object belongs to (`backTarget`, e.g. "Adapters"), the breadcrumbs and the
+ * actions slot.
+ *
+ * An empty breadcrumb line (AB#5621) takes no height: when the `[spaceCrumbs]` content shows
+ * nothing (no text, no list item, link, button or image — e.g. a Kendo breadcrumb without
+ * items) and there is no back link, the line collapses. It stays in the DOM with its width, so
+ * a breadcrumb that measures its width (Kendo's collapse mode) is laid out right once items arrive.
+ */
+declare class SpaceShellComponent {
+    private readonly host;
+    readonly area: _angular_core.InputSignal<ShellNavNode | null>;
+    readonly activeTabId: _angular_core.InputSignal<string | null>;
+    readonly chips: _angular_core.InputSignal<SpaceStatusChip[]>;
+    /** Replaces the area name as the title (Home: the greeting, AB#5558). */
+    readonly heading: _angular_core.InputSignal<string | null>;
+    /** A short meta line right of the title (Home: the tenant), hidden on phones. */
+    readonly meta: _angular_core.InputSignal<SpaceMetaItem[]>;
+    /** The page renders its own object header; area title, chips and tabs are left out. */
+    readonly objectDetail: _angular_core.InputSignal<boolean>;
+    /** Show the area's tab strip; false when the page lists the same entries itself (Settings home). */
+    readonly showTabs: _angular_core.InputSignal<boolean>;
+    /** Target of the back link on an object detail page (the list of the object). */
+    readonly backTarget: _angular_core.InputSignal<ShellNavNode | null>;
+    /** Translations; members left out fall back to {@link SHELL_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<ShellMessages> | null>;
+    protected readonly m: _angular_core.Signal<ShellMessages>;
+    readonly tabSelected: _angular_core.OutputEmitterRef<ShellNavNode>;
+    /** The grouping tab whose menu is open. */
+    protected readonly openMenuId: _angular_core.WritableSignal<string | null>;
+    protected readonly menuPosition: _angular_core.WritableSignal<MenuPosition>;
+    protected readonly tabs: _angular_core.Signal<ShellNavNode[]>;
+    /** The breadcrumb line shows something (projected crumbs or the back link). */
+    protected readonly hasCrumbs: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** Scrolls the tab strip (only it, never the page) so the tab is fully visible. */
+    revealTab(id: string): void;
+    private crumbsElement;
+    private updateHasCrumbs;
+    protected format(message: string, values: Record<string, string>): string;
+    protected onBackClick(target: ShellNavNode): void;
+    protected isGroup(tab: ShellNavNode): boolean;
+    protected menuId(tab: ShellNavNode): string;
+    protected onTabClick(tab: ShellNavNode, button: HTMLElement): void;
+    protected onTabKeydown(tab: ShellNavNode, button: HTMLElement, event: KeyboardEvent): void;
+    protected onMenuItemClick(item: ShellNavNode): void;
+    protected onMenuKeydown(event: KeyboardEvent): void;
+    protected onWrapperFocusOut(tab: ShellNavNode, event: FocusEvent): void;
+    protected onDocumentClick(target: EventTarget | null): void;
+    protected onViewportChange(): void;
+    private openMenu;
+    private closeMenu;
+    private openWrapper;
+    private menuItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpaceShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpaceShellComponent, "mm-space-shell", never, { "area": { "alias": "area"; "required": false; "isSignal": true; }; "activeTabId": { "alias": "activeTabId"; "required": false; "isSignal": true; }; "chips": { "alias": "chips"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "meta": { "alias": "meta"; "required": false; "isSignal": true; }; "objectDetail": { "alias": "objectDetail"; "required": false; "isSignal": true; }; "showTabs": { "alias": "showTabs"; "required": false; "isSignal": true; }; "backTarget": { "alias": "backTarget"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "tabSelected": "tabSelected"; }, never, ["[spaceCrumbs]", "[spaceActions]"], true, never>;
+}
+
+/** Badge of one Settings category in the side navigation. */
+interface SettingsSideNavBadge {
+    count: number;
+    /** Needs attention (open re-entry tasks): rendered as a warning badge. */
+    attention?: boolean;
+    /** Accessible label of the badge; without one the count is read as is. */
+    label?: string;
+}
+/**
+ * Counts and badges of the Settings side navigation, keyed by shell tab id
+ * (`settings-<category>`). The Settings home fills them when it has loaded its
+ * categories (forms + custom pages) and the secrets inventory; until then, and on a
+ * deep link to another Settings page, the categories are shown without counts.
+ */
+declare class SettingsSideNavBadgesService {
+    private readonly _badges;
+    readonly badges: _angular_core.Signal<Record<string, SettingsSideNavBadge>>;
+    set(badges: Record<string, SettingsSideNavBadge>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsSideNavBadgesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SettingsSideNavBadgesService>;
+}
+
+/**
+ * A heading over some categories of the Settings side navigation (AB#5621).
+ */
+interface SettingsSideNavGroup {
+    id: string;
+    /** Visible heading (already translated by the host). */
+    label: string;
+    /** Tab ids of the categories under the heading, in display order. */
+    tabIds: readonly string[];
+}
+/** One block of the side navigation: a group with its categories, or the ungrouped ones. */
+interface SideNavSection {
+    id: string;
+    label: string | null;
+    categories: ShellNavNode[];
+}
+/**
+ * The one navigation of the Settings space (concept §5.6, AB#5523): "All settings" plus the
+ * categories of the Settings area on the left, on every Settings page — the home, the category
+ * pages, the generated forms and the hand-written pages (secrets, identity providers, …). The
+ * space header shows no tab strip in Settings, so opening a category never switches between two
+ * navigation layouts.
+ *
+ * The entries are the area's children from the command tree (the same entries as the rail
+ * flyout); counts and the re-entry badge come from {@link SettingsSideNavBadgesService}.
+ * Navigation, not ARIA tabs: a `nav` with buttons and `aria-current="page"` on the active one.
+ *
+ * Groups (AB#5621, optional): `groups` puts headings over the categories they list (in the
+ * group's order); categories in no group follow without a heading, groups without a visible
+ * category are left out. Without groups the list is flat, as before.
+ *
+ * Labels are shown exactly as given (AB#5621): the area name, the categories and the group
+ * headings keep the host's case — no lower-casing, no CSS `text-transform`. A language that
+ * needs a different case in "All {area}" sets `allOfArea` to the whole text.
+ */
+declare class SettingsSideNavComponent {
+    readonly area: _angular_core.InputSignal<ShellNavNode>;
+    readonly activeTabId: _angular_core.InputSignal<string | null>;
+    /** The Settings home is open ("All settings" is the current entry). */
+    readonly homeActive: _angular_core.InputSignal<boolean>;
+    readonly badges: _angular_core.InputSignal<Record<string, SettingsSideNavBadge>>;
+    /** Optional headings over the categories; empty keeps the flat list. */
+    readonly groups: _angular_core.InputSignal<readonly SettingsSideNavGroup[]>;
+    /** Translations; members left out fall back to {@link SHELL_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<ShellMessages> | null>;
+    protected readonly m: _angular_core.Signal<ShellMessages>;
+    readonly homeSelected: _angular_core.OutputEmitterRef<void>;
+    readonly tabSelected: _angular_core.OutputEmitterRef<ShellNavNode>;
+    protected readonly categories: _angular_core.Signal<ShellNavNode[]>;
+    protected readonly sections: _angular_core.Signal<SideNavSection[]>;
+    /** Unique per instance, so two side navs on one page never share heading ids. */
+    private readonly instanceId;
+    protected groupHeadingId(section: SideNavSection): string;
+    protected readonly navLabel: _angular_core.Signal<string>;
+    protected readonly homeLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsSideNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsSideNavComponent, "mm-settings-side-nav", never, { "area": { "alias": "area"; "required": true; "isSignal": true; }; "activeTabId": { "alias": "activeTabId"; "required": false; "isSignal": true; }; "homeActive": { "alias": "homeActive"; "required": false; "isSignal": true; }; "badges": { "alias": "badges"; "required": false; "isSignal": true; }; "groups": { "alias": "groups"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "homeSelected": "homeSelected"; "tabSelected": "tabSelected"; }, never, never, true, never>;
+}
+
+/** One density choice of the user menu (the host owns the density modes and applies them). */
+interface ShellDensityOption {
+    mode: string;
+    label: string;
+}
+/** One language of the user menu's language choice. */
+interface ShellLanguage {
+    /** Language code the host understands, e.g. `'en'` or `'de-AT'`. */
+    code: string;
+    /** Name of the language, ideally in that language ("Deutsch"). */
+    label: string;
+}
+/** The default language list: English only, shown as a fact instead of a choice. */
+declare const DEFAULT_SHELL_LANGUAGES: readonly ShellLanguage[];
+/** Theme preference of the user menu (same values as octo-ui's `ThemeModePreference`). */
+type ShellThemePreference = 'system' | 'light' | 'dark';
+/** The signed-in user as the user menu shows it. */
+interface ShellUser {
+    /** Avatar initials; empty shows "?". */
+    initials?: string | null;
+    /** Full name, e.g. "Gerald Lochner". */
+    displayName?: string | null;
+    /** Login / account name, e.g. "gerald". */
+    userName?: string | null;
+    /** Account page of the identity provider; null leaves "Manage profile" out. */
+    profileUri?: string | null;
+}
+/**
+ * A host entry of the user menu (AB#5621), e.g. "My identities" or "Developer info". Listed
+ * above "Manage profile" and "Sign out".
+ */
+interface ShellUserMenuItem {
+    id: string;
+    /** Visible label (already translated by the host). */
+    text: string;
+    svgIcon?: SVGIcon;
+    /** External link, opened in a new tab; without one choosing the entry emits `itemSelected`. */
+    href?: string;
+}
+interface ThemeOption {
+    value: ShellThemePreference;
+    label: string;
+}
+/**
+ * Avatar menu of the top bar. Besides sign-out and the profile link it holds
+ * the personal settings (concept §3.1, §10): theme mode, density and
+ * language. Tenant configuration belongs elsewhere (the Settings space).
+ *
+ * - **Session**: `sessionLoading` shows a placeholder, `user` null offers "Sign in"
+ *   (`signIn` output), otherwise the avatar opens the panel; "Sign out" emits `signOut`.
+ *   The host wires its auth service (e.g. shared-auth's `AuthorizeService`).
+ * - **Theme**: `theme` is the current preference, a choice emits `themeChange` (e.g. wired to
+ *   octo-ui's `ThemeModeService`).
+ * - **Density** lists `densityOptions` (none: the group is left out); a choice emits
+ *   `densityChange`, the host applies and stores it and feeds `density` back.
+ * - **Language** lists `languages`. With one language (the default, English) the entry
+ *   states it instead of offering a choice that changes nothing; with several it is a
+ *   radio group that emits `languageChange`. Persisting the choice (per user) and
+ *   switching the translations is the host's job; it feeds the current code back
+ *   through `language`.
+ * - **Version** shows `version` when set.
+ * - **Host entries** (AB#5621): `items` lists the host's own entries above "Manage profile" and
+ *   "Sign out"; choosing one closes the panel and emits `itemSelected` (entries with `href`
+ *   open in a new tab instead). For richer content the host may project elements with the
+ *   `shellUserMenuItems` attribute into the same place; a click on a button or link there
+ *   closes the panel as well.
+ *
+ * Opening moves focus into the panel, Escape or the avatar button close it
+ * and return focus to the avatar. Theme, density and language are native radio groups
+ * (arrow keys move and select, one tab stop each).
+ */
+declare class ShellUserMenuComponent {
+    private readonly host;
+    /** The signed-in user; null shows the "Sign in" button. */
+    readonly user: _angular_core.InputSignal<ShellUser | null>;
+    /** The session is being restored: a placeholder instead of avatar or sign-in. */
+    readonly sessionLoading: _angular_core.InputSignal<boolean>;
+    /** The current theme preference. */
+    readonly theme: _angular_core.InputSignal<ShellThemePreference>;
+    /** Density choices; empty leaves the density group out. */
+    readonly densityOptions: _angular_core.InputSignal<readonly ShellDensityOption[]>;
+    /** The current density mode (one of `densityOptions`). */
+    readonly density: _angular_core.InputSignal<string | null>;
+    /** Languages to choose from; one entry is shown as a fact, none hides the entry. */
+    readonly languages: _angular_core.InputSignal<readonly ShellLanguage[]>;
+    /** The current language code; defaults to the first of `languages`. */
+    readonly language: _angular_core.InputSignal<string | null>;
+    /** App version shown at the bottom of the panel; null leaves the line out. */
+    readonly version: _angular_core.InputSignal<string | null>;
+    /** Host entries above "Manage profile" / "Sign out"; empty leaves the list out. */
+    readonly items: _angular_core.InputSignal<readonly ShellUserMenuItem[]>;
+    /** Translations; members left out fall back to {@link SHELL_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<ShellMessages> | null>;
+    readonly signIn: _angular_core.OutputEmitterRef<void>;
+    readonly signOut: _angular_core.OutputEmitterRef<void>;
+    /** The person picked a theme preference. */
+    readonly themeChange: _angular_core.OutputEmitterRef<ShellThemePreference>;
+    /** The person picked a density mode. */
+    readonly densityChange: _angular_core.OutputEmitterRef<string>;
+    /** The person picked a language (its code). */
+    readonly languageChange: _angular_core.OutputEmitterRef<string>;
+    /** The person chose a host entry without `href`. */
+    readonly itemSelected: _angular_core.OutputEmitterRef<ShellUserMenuItem>;
+    protected readonly m: _angular_core.Signal<ShellMessages>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly initials: _angular_core.Signal<string>;
+    protected readonly fullName: _angular_core.Signal<string | null>;
+    protected readonly userName: _angular_core.Signal<string | null>;
+    protected readonly profileUri: _angular_core.Signal<string | null>;
+    protected readonly avatarLabel: _angular_core.Signal<string>;
+    protected readonly versionText: _angular_core.Signal<string | null>;
+    protected readonly themeOptions: _angular_core.Signal<readonly ThemeOption[]>;
+    /** The code of the current language: `language`, else the first of `languages`. */
+    protected readonly currentLanguage: _angular_core.Signal<string>;
+    protected readonly currentLanguageLabel: _angular_core.Signal<string>;
+    protected toggle(): void;
+    /** Closes the panel; `restoreFocus` puts focus back on the avatar button. */
+    private close;
+    protected setTheme(value: ShellThemePreference): void;
+    protected setDensity(mode: string): void;
+    protected setLanguage(code: string): void;
+    /** A host entry: close the panel (focus back on the avatar), then let the host act. */
+    protected selectItem(item: ShellUserMenuItem): void;
+    /** An external host entry opens in a new tab; the panel closes and focus returns to the avatar. */
+    protected followItemLink(): void;
+    /** A click on a button or link of the projected `shellUserMenuItems` content closes the panel. */
+    protected onProjectedClick(event: Event): void;
+    protected login(): void;
+    protected logout(): void;
+    protected onEscape(): void;
+    /** A click outside closes without stealing focus from what was clicked. */
+    protected onDocumentClick(target: EventTarget | null): void;
+    /** Tabbing out of the panel closes it. */
+    protected onPanelFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellUserMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellUserMenuComponent, "mm-shell-user-menu", never, { "user": { "alias": "user"; "required": false; "isSignal": true; }; "sessionLoading": { "alias": "sessionLoading"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "densityOptions": { "alias": "densityOptions"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "languages": { "alias": "languages"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "signIn": "signIn"; "signOut": "signOut"; "themeChange": "themeChange"; "densityChange": "densityChange"; "languageChange": "languageChange"; "itemSelected": "itemSelected"; }, never, ["[shellUserMenuItems]"], true, never>;
+}
+
+/** One choice of the top bar's mode switch (e.g. Home | Studio). */
+interface ShellModeOption {
+    id: string;
+    label: string;
+    /** Tooltip. */
+    description?: string;
+}
+/**
+ * Top bar (concept §3.1, wireframe): brand mark + name, tenant switcher with the
+ * environment chip, the mode switch, the search trigger, the optional ✦ assistant
+ * toggle and the avatar menu (`mm-shell-user-menu`) with the personal settings.
+ *
+ * Pure presentation; the host feeds everything in and handles the outputs:
+ *
+ * - **Brand**: `brandName` and `brandMarkSrc` (an image URL of the host; none: no mark).
+ * - **Tenant**: inside a tenant (`tenantId`) the host projects its tenant switcher with the
+ *   `shellTenant` attribute (e.g. octo-ui's `<mm-tenant-switcher shellTenant …>`, which the
+ *   bar styles flat); the environment chip follows it.
+ * - **Environment**: `environment` (e.g. from {@link shellEnvironmentChip}); null hides the
+ *   chip (also while the tenant mode is loading). `production: true` tints the bar.
+ * - **Mode switch**: `modes` + `currentMode`; shown with two or more modes inside a tenant
+ *   the user may open. Picking the other mode emits `modeChange`; the host applies it.
+ * - **Search**: the button calls {@link ShellSearchTriggerService.request} and emits
+ *   `searchRequested`; the host (or the palette) opens the command palette.
+ * - **Assistant**: `assistantAvailable` shows the ✦ toggle (inside a tenant the user may
+ *   open); a click emits `assistantToggle`, `assistantOpen` reflects the panel state.
+ * - **User menu**: `user`, `sessionLoading`, `theme`, `densityOptions`, `density`,
+ *   `languages`, `language`, `version` and the outputs `signIn`, `signOut`, `themeChange`,
+ *   `densityChange` and `languageChange` are passed through to `mm-shell-user-menu`, as are the
+ *   host entries (AB#5621): `userMenuItems` → `items`, `itemSelected` → `userMenuItemSelected`,
+ *   and content with the `shellUserMenuItems` attribute, projected into the panel.
+ */
+declare class ShellTopBarComponent {
+    private readonly searchTrigger;
+    readonly tenantId: _angular_core.InputSignal<string | null>;
+    readonly isDenied: _angular_core.InputSignal<boolean>;
+    /** Product name next to the mark, e.g. "OctoMesh Studio". */
+    readonly brandName: _angular_core.InputSignal<string>;
+    /** URL of the brand mark image (decorative); null leaves the mark out. */
+    readonly brandMarkSrc: _angular_core.InputSignal<string | null>;
+    /** The tenant's environment chip; null hides it. */
+    readonly environment: _angular_core.InputSignal<ShellEnvironmentChip | null>;
+    /** Choices of the mode switch; fewer than two hide it. */
+    readonly modes: _angular_core.InputSignal<readonly ShellModeOption[]>;
+    /** Id of the mode in effect. */
+    readonly currentMode: _angular_core.InputSignal<string | null>;
+    /** Shows the ✦ assistant toggle (feature flag on and the panel can be hosted). */
+    readonly assistantAvailable: _angular_core.InputSignal<boolean>;
+    /** The assistant panel is open (`aria-expanded` of the toggle). */
+    readonly assistantOpen: _angular_core.InputSignal<boolean>;
+    /** Id of the assistant panel element (`aria-controls` while open). */
+    readonly assistantPanelId: _angular_core.InputSignal<string>;
+    readonly user: _angular_core.InputSignal<ShellUser | null>;
+    readonly sessionLoading: _angular_core.InputSignal<boolean>;
+    readonly theme: _angular_core.InputSignal<ShellThemePreference>;
+    readonly densityOptions: _angular_core.InputSignal<readonly ShellDensityOption[]>;
+    readonly density: _angular_core.InputSignal<string | null>;
+    readonly languages: _angular_core.InputSignal<readonly ShellLanguage[]>;
+    readonly language: _angular_core.InputSignal<string | null>;
+    readonly version: _angular_core.InputSignal<string | null>;
+    /** Host entries of the user menu (its `items`). */
+    readonly userMenuItems: _angular_core.InputSignal<readonly ShellUserMenuItem[]>;
+    /** Translations; members left out fall back to {@link SHELL_MESSAGES}, then English. */
+    readonly messages: _angular_core.InputSignal<Partial<ShellMessages> | null>;
+    /** The person picked the other mode; the host applies it and rebuilds the navigation. */
+    readonly modeChange: _angular_core.OutputEmitterRef<string>;
+    /** The search trigger was used. */
+    readonly searchRequested: _angular_core.OutputEmitterRef<void>;
+    /** The ✦ toggle was used. */
+    readonly assistantToggle: _angular_core.OutputEmitterRef<void>;
+    readonly signIn: _angular_core.OutputEmitterRef<void>;
+    readonly signOut: _angular_core.OutputEmitterRef<void>;
+    readonly themeChange: _angular_core.OutputEmitterRef<ShellThemePreference>;
+    readonly densityChange: _angular_core.OutputEmitterRef<string>;
+    readonly languageChange: _angular_core.OutputEmitterRef<string>;
+    /** A host entry of the user menu was chosen (its `itemSelected`). */
+    readonly userMenuItemSelected: _angular_core.OutputEmitterRef<ShellUserMenuItem>;
+    protected readonly m: _angular_core.Signal<ShellMessages>;
+    protected readonly isProduction: _angular_core.Signal<boolean>;
+    protected readonly showEnvironment: _angular_core.Signal<boolean>;
+    /** A switch with one choice would be noise (e.g. users without builder roles). */
+    protected readonly showModeSwitch: _angular_core.Signal<boolean>;
+    /** The ✦ toggle: only when available and inside a tenant the user may open. */
+    protected readonly showAssistant: _angular_core.Signal<boolean>;
+    /** ⌘K on Apple platforms, Ctrl K elsewhere — the shortcut the palette binds. */
+    private readonly isApple;
+    protected readonly shortcutLabel: string;
+    /** ⌘J / Ctrl J — the assistant shortcut the host binds. */
+    protected readonly assistantShortcutLabel: string;
+    /** Both chords work everywhere; the platform's usual one is listed first. */
+    protected readonly assistantKeyShortcut: string;
+    protected selectMode(mode: string): void;
+    protected toggleAssistant(): void;
+    protected requestSearch(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellTopBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellTopBarComponent, "mm-shell-top-bar", never, { "tenantId": { "alias": "tenantId"; "required": false; "isSignal": true; }; "isDenied": { "alias": "isDenied"; "required": false; "isSignal": true; }; "brandName": { "alias": "brandName"; "required": false; "isSignal": true; }; "brandMarkSrc": { "alias": "brandMarkSrc"; "required": false; "isSignal": true; }; "environment": { "alias": "environment"; "required": false; "isSignal": true; }; "modes": { "alias": "modes"; "required": false; "isSignal": true; }; "currentMode": { "alias": "currentMode"; "required": false; "isSignal": true; }; "assistantAvailable": { "alias": "assistantAvailable"; "required": false; "isSignal": true; }; "assistantOpen": { "alias": "assistantOpen"; "required": false; "isSignal": true; }; "assistantPanelId": { "alias": "assistantPanelId"; "required": false; "isSignal": true; }; "user": { "alias": "user"; "required": false; "isSignal": true; }; "sessionLoading": { "alias": "sessionLoading"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "densityOptions": { "alias": "densityOptions"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "languages": { "alias": "languages"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "userMenuItems": { "alias": "userMenuItems"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "modeChange": "modeChange"; "searchRequested": "searchRequested"; "assistantToggle": "assistantToggle"; "signIn": "signIn"; "signOut": "signOut"; "themeChange": "themeChange"; "densityChange": "densityChange"; "languageChange": "languageChange"; "userMenuItemSelected": "userMenuItemSelected"; }, never, ["[shellTenant]", "[shellUserMenuItems]"], true, never>;
+}
+
+export { DEFAULT_SHELL_LANGUAGES, DEFAULT_SHELL_MESSAGES, RAIL_BOTTOM_SEPARATOR_ID, RAIL_FLYOUT_CLOSE_DELAY, RAIL_FLYOUT_OPEN_DELAY, SHELL_BADGE_MAX, SHELL_MESSAGES, SHELL_NOTIFICATION_OPTIONS, SHELL_SETTINGS_SPACE, SettingsSideNavBadgesService, SettingsSideNavComponent, ShellNavigationService, ShellRailComponent, ShellSearchTriggerService, ShellTopBarComponent, ShellUserMenuComponent, SpaceHeaderService, SpaceShellComponent, areaId, crumbPath, firstNameOf, formatShellMessage, greetingPhrase, homeGreeting, homeMeta, isAreaCrumb, resolveShellBadge, resolveShellMessages, shellBadgeText, shellBreadcrumbs, shellEnvironmentChip, spaceOfAreaId, tabId };
+export type { GreetingUser, SettingsSideNavBadge, SettingsSideNavGroup, ShellAreaCrumb, ShellBreadcrumbOptions, ShellDensityOption, ShellEnvironmentChip, ShellEnvironmentMode, ShellLanguage, ShellMessages, ShellModeOption, ShellNavBadge, ShellNavBadges, ShellNavItemKind, ShellNavNode, ShellRouteData, ShellStatus, ShellThemePreference, ShellUser, ShellUserMenuItem, SpaceMetaItem, SpaceStatusChip };