@akcelik/strct 1.22.0 → 2.0.1

package/types/akcelik-strct.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { OnDestroy, InjectionToken, Provider, TemplateRef, PipeTransform } from '@angular/core';
+import { OnDestroy, ElementRef, InjectionToken, Provider, TemplateRef, PipeTransform } from '@angular/core';
 import { SafeHtml, SafeStyle } from '@angular/platform-browser';
 import { ControlValueAccessor } from '@angular/forms';
 import * as _akcelik_strct from '@akcelik/strct';
@@ -51,8 +51,11 @@ declare class StrctThemeService {
 /** Palette dots + light/dark pill, wired to {@link StrctThemeService}. */
 declare class StrctThemeSwitcher {
     protected readonly theme: StrctThemeService;
+    /** Labels for the Light / Dark mode buttons (localizable). */
+    readonly lightLabel: _angular_core.InputSignal<string>;
+    readonly darkLabel: _angular_core.InputSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctThemeSwitcher, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctThemeSwitcher, "strct-theme-switcher", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctThemeSwitcher, "strct-theme-switcher", never, { "lightLabel": { "alias": "lightLabel"; "required": false; "isSignal": true; }; "darkLabel": { "alias": "darkLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -379,10 +382,14 @@ declare class StrctOverlay implements OnDestroy {
     private readonly zone;
     /** Anchor element for positioning. */
     readonly anchor: _angular_core.InputSignal<HTMLElement>;
-    /** Preferred placement relative to the anchor. */
+    /**
+     * Preferred placement relative to the anchor. `start`/`end` follow the
+     * anchor's text direction (mirrored under RTL); `left`/`right` are
+     * physical sides in every direction.
+     */
     readonly placement: _angular_core.InputSignal<StrctOverlayPlacement>;
     /** Match the panel width to the anchor (combobox / date / cascade fields). */
-    readonly matchWidth: _angular_core.InputSignal<boolean>;
+    readonly matchWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Gap between anchor and panel in pixels. */
     readonly gap: _angular_core.InputSignal<number>;
     private readonly onScrollResize;
@@ -398,6 +405,8 @@ declare class StrctOverlay implements OnDestroy {
 /** Shared layout state between shell parts. */
 declare class StrctShellService {
     readonly mobileNavOpen: _angular_core.WritableSignal<boolean>;
+    /** Id of the vertical nav controlled by the header drawer toggle. */
+    readonly navId: string;
 }
 /**
  * Application frame: a full-viewport grid of header / body / footer rows.
@@ -413,9 +422,11 @@ declare class StrctShell {
 }
 /** Top application bar. Holds brand on the left and actions on the right. */
 declare class StrctHeader {
+    /** Accessible label of the mobile drawer toggle. */
+    readonly drawerToggleAriaLabel: _angular_core.InputSignal<string>;
     protected readonly shell: StrctShellService;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHeader, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHeader, "strct-header", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHeader, "strct-header", never, { "drawerToggleAriaLabel": { "alias": "drawerToggleAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 /** Bottom status bar. */
 declare class StrctFooter {
@@ -426,6 +437,8 @@ declare class StrctFooter {
 /** Scrollable left sidebar surface. Holds the icon nav and/or a tree. */
 declare class StrctVerticalNav {
     protected readonly shell: StrctShellService;
+    /** Closes the mobile nav on Escape. */
+    protected onEscape(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctVerticalNav, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctVerticalNav, "strct-vertical-nav", never, {}, {}, never, ["*"], true, never>;
 }
@@ -437,9 +450,12 @@ declare class StrctNav {
 /** A single icon tab inside `<strct-nav>`. */
 declare class StrctNavItem {
     /** Whether the item is active / selected. */
-    readonly active: _angular_core.InputSignal<boolean>;
+    readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Label text. */
     readonly label: _angular_core.InputSignal<string>;
+    private readonly host;
+    /** Activates the item from the keyboard, like a native button. */
+    protected activate(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctNavItem, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctNavItem, "strct-nav-item", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -491,9 +507,15 @@ declare class StrctRail {
     /** Collapsed (icon-only) state (two-way). */
     readonly collapsed: _angular_core.ModelSignal<boolean>;
     /** Show the collapse toggle at the foot of the rail. */
-    readonly collapsible: _angular_core.InputSignal<boolean>;
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Accessible label for the nav landmark. */
     readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the foot toggle when the rail is collapsed. */
+    readonly expandAriaLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the foot toggle when the rail is expanded. */
+    readonly collapseAriaLabel: _angular_core.InputSignal<string>;
+    /** Visible text of the foot toggle (expanded state). */
+    readonly collapseText: _angular_core.InputSignal<string>;
     /** Emitted when an item is chosen. */
     readonly select: _angular_core.OutputEmitterRef<StrctRailItem>;
     protected readonly topItems: _angular_core.Signal<StrctRailItem[]>;
@@ -507,7 +529,7 @@ declare class StrctRail {
     protected isActive(item: StrctRailItem, routerActive: boolean): boolean;
     protected pick(item: StrctRailItem, event?: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRail, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRail, "strct-rail", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "activeId": { "alias": "activeId"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "activeId": "activeIdChange"; "collapsed": "collapsedChange"; "select": "select"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRail, "strct-rail", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "activeId": { "alias": "activeId"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "expandAriaLabel": { "alias": "expandAriaLabel"; "required": false; "isSignal": true; }; "collapseAriaLabel": { "alias": "collapseAriaLabel"; "required": false; "isSignal": true; }; "collapseText": { "alias": "collapseText"; "required": false; "isSignal": true; }; }, { "activeId": "activeIdChange"; "collapsed": "collapsedChange"; "select": "select"; }, never, never, true, never>;
 }
 
 /**
@@ -618,10 +640,14 @@ declare class StrctTag {
     readonly status: _angular_core.InputSignal<StrctTagStatus>;
     /** Show a remove button. */
     readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Hide the remove button (e.g. when the parent control is disabled). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible label for the remove button. */
+    readonly removeLabel: _angular_core.InputSignal<string>;
     /** Emitted when the user clicks the remove button. */
     readonly removed: _angular_core.OutputEmitterRef<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTag, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTag, "strct-tag", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTag, "strct-tag", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
 }
 
 /** Avatar size variants. */
@@ -713,14 +739,20 @@ declare class StrctSpeedDial {
     private readonly host;
     /** Icon name. */
     readonly icon: _angular_core.InputSignal<string>;
+    /** Accessible name for the icon-only FAB. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     /** Direction the actions fan out. */
     readonly direction: _angular_core.InputSignal<StrctSpeedDialDirection>;
     readonly open: _angular_core.WritableSignal<boolean>;
+    /** Trigger to hand focus back to on Escape close. */
+    private trigger;
     toggle(): void;
+    /** Activating a projected action closes the dial (the FAB toggles itself). */
+    protected onActionClick(): void;
     protected onDocClick(event: MouseEvent): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSpeedDial, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSpeedDial, "strct-speed-dial", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSpeedDial, "strct-speed-dial", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -793,6 +825,8 @@ declare class StrctAccordionPanel {
     readonly heading: _angular_core.InputSignal<string>;
     /** Whether the panel is open (two-way). */
     readonly expanded: _angular_core.ModelSignal<boolean>;
+    protected readonly bodyId: string;
+    protected readonly headId: string;
     toggle(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctAccordionPanel, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctAccordionPanel, "strct-accordion-panel", never, { "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
@@ -804,10 +838,20 @@ declare class StrctTab {
     readonly label: _angular_core.InputSignal<string>;
     /** Static disable flag. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly _id;
+    /** Id of this tab's panel element. */
+    readonly panelId: string;
+    /** Id of this tab's button element. */
+    readonly buttonId: string;
     private readonly _active;
     readonly active: _angular_core.Signal<boolean>;
+    private readonly _keepAlive;
+    /** Whether inactive content stays in the DOM (hidden) instead of being destroyed. */
+    readonly keepAlive: _angular_core.Signal<boolean>;
     /** @internal called by the parent tab group */
     setActive(value: boolean): void;
+    /** @internal called by the parent tab group */
+    setKeepAlive(value: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTab, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTab, "strct-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -815,11 +859,16 @@ declare class StrctTab {
 declare class StrctTabs {
     readonly tabs: _angular_core.Signal<readonly StrctTab[]>;
     readonly selectedIndex: _angular_core.ModelSignal<number>;
+    /**
+     * Keep inactive panels in the DOM with the `hidden` attribute instead of
+     * destroying them, preserving their state (e.g. form values) across switches.
+     */
+    readonly keepAlive: _angular_core.InputSignalWithTransform<boolean, unknown>;
     constructor();
     select(index: number): void;
     onKeydown(event: KeyboardEvent, bar: HTMLElement): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTabs, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTabs, "strct-tabs", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; }, ["tabs"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTabs, "strct-tabs", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "keepAlive": { "alias": "keepAlive"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; }, ["tabs"], ["*"], true, never>;
 }
 
 /** A single entry in a data-driven menu. */
@@ -865,6 +914,8 @@ declare class StrctMenuPanel {
     readonly back: _angular_core.OutputEmitterRef<void>;
     protected readonly posX: _angular_core.WritableSignal<number>;
     protected readonly posY: _angular_core.WritableSignal<number>;
+    /** Vertical offset of a submenu fly-out (matches the CSS `top: -5px` default). */
+    protected readonly subTop: _angular_core.WritableSignal<number>;
     protected readonly flipLeft: _angular_core.WritableSignal<boolean>;
     protected readonly activeIndex: _angular_core.WritableSignal<number>;
     protected readonly openSubIndex: _angular_core.WritableSignal<number | null>;
@@ -904,6 +955,8 @@ declare class StrctMenuService {
     private readonly zone;
     private readonly doc;
     private ref;
+    /** Element focused before opening — focus returns here on close. */
+    private restoreTo;
     open(opts: StrctMenuOpenOptions): void;
     private readonly onClose;
     private readonly onOutside;
@@ -978,7 +1031,7 @@ declare class StrctTreeNode {
     /** Status dot variant. */
     readonly badge: _angular_core.InputSignal<StrctIconBadge>;
     /** Whether the item is active / selected. */
-    readonly active: _angular_core.InputSignal<boolean>;
+    readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the panel is open (two-way). */
     readonly expanded: _angular_core.ModelSignal<boolean>;
     /** Per-node menu resolver (data mode); bubbles down the recursion. */
@@ -1000,18 +1053,37 @@ declare class StrctTreeNode {
     /** 1-based depth, exposed as aria-level. */
     readonly level: number;
     private readonly hostEl;
+    private readonly _id;
+    /** Id of the children group container — the row's aria-owns target. */
+    protected readonly groupId: string;
     private readonly childNodes;
+    /** Direct projected children only (descendants would skew the sibling count). */
+    private readonly directChildNodes;
     /** Data-mode expansion fallback when there is no owning tree (seeded from node.expanded). */
     private readonly dataExpanded;
     protected readonly displayLabel: _angular_core.Signal<string>;
     protected readonly displayIcon: _angular_core.Signal<string | undefined>;
     protected readonly displayBadge: _angular_core.Signal<StrctIconBadge>;
     protected readonly displayActive: _angular_core.Signal<boolean>;
+    /** Data-mode siblings (null in content mode): the parent's children, else the tree roots. */
+    private readonly siblingData;
+    /** Content-mode siblings: the parent's (or owning tree's) direct projected nodes. */
+    private readonly contentSiblings;
+    /** Sibling count, exposed as aria-setsize. */
+    protected readonly setSize: _angular_core.Signal<number>;
+    /** 1-based position among the siblings, exposed as aria-posinset. */
+    protected readonly posInSet: _angular_core.Signal<number>;
+    /** Direct projected child nodes (content mode) — sibling source for aria-setsize/posinset. */
+    contentChildNodes(): readonly StrctTreeNode[];
+    /** Visible label text — matched by the owning tree's typeahead. */
+    typeaheadLabel(): string;
     constructor();
     /** The focusable row element of this node. */
     rowEl(): HTMLElement | null;
     /** Roving tabindex: inside a tree only the active row is tabbable. */
     protected readonly rowTabindex: _angular_core.Signal<0 | -1>;
+    /** Accessible label of the chevron toggle (factory from the owning tree). */
+    protected readonly chevronAriaLabel: _angular_core.Signal<string>;
     protected onRowFocus(): void;
     protected onRowKeydown(event: KeyboardEvent): void;
     readonly hasChildren: _angular_core.Signal<boolean>;
@@ -1020,7 +1092,7 @@ declare class StrctTreeNode {
     protected onActivate(): void;
     protected onMenuSelect(item: StrctMenuItem): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTreeNode, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTreeNode, "strct-tree-node", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "nodeMenu": { "alias": "nodeMenu"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "activated": "activated"; "nodeActivated": "nodeActivated"; "nodeMenuSelect": "nodeMenuSelect"; }, ["childNodes"], ["[strctTreeTrailing]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTreeNode, "strct-tree-node", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "nodeMenu": { "alias": "nodeMenu"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "activated": "activated"; "nodeActivated": "nodeActivated"; "nodeMenuSelect": "nodeMenuSelect"; }, ["childNodes", "directChildNodes"], ["[strctTreeTrailing]", "*"], true, never>;
 }
 /**
  * Root container for a tree. Either project `<strct-tree-node>` children, or
@@ -1038,6 +1110,8 @@ declare class StrctTree {
     readonly density: _angular_core.InputSignal<"compact" | "comfortable">;
     /** Per-node right-click menu resolver. */
     readonly nodeMenu: _angular_core.InputSignal<StrctTreeNodeMenuFn | null>;
+    /** Accessible label of each node's chevron toggle; receives the expanded state and the node label. */
+    readonly chevronAriaLabel: _angular_core.InputSignal<(expanded: boolean, label: string) => string>;
     /** Emitted when any data-driven node is clicked. */
     readonly nodeActivated: _angular_core.OutputEmitterRef<StrctTreeNodeData>;
     /** Emitted when a data-driven node's right-click menu item is chosen. */
@@ -1069,8 +1143,16 @@ declare class StrctTree {
     isNodeOpen(node: StrctTreeNodeData): boolean;
     private readonly registeredNodes;
     private readonly activeRoving;
+    /** Direct projected root nodes (content mode) — sibling source for aria-setsize/posinset. */
+    private readonly projectedNodes;
+    /** Document-ordered cache of the visible nodes; null = stale. */
+    private orderedCache;
+    /** `nodes` identity the cache was built for (data-mode `@for` can reorder in place). */
+    private orderedCacheNodes;
     registerNode(node: StrctTreeNode): void;
     unregisterNode(node: StrctTreeNode): void;
+    /** Direct projected root nodes (content mode); empty in data mode. */
+    contentChildNodes(): readonly StrctTreeNode[];
     /** Visible nodes in document order (collapsed subtrees are never registered). */
     private ordered;
     /** Whether this node currently holds the roving tabindex (0). */
@@ -1079,10 +1161,20 @@ declare class StrctTree {
     private focusNode;
     /** Keyboard navigation between visible rows (called from the focused node). */
     navigate(node: StrctTreeNode, key: string): void;
+    /** Idle gap after which the accumulated typeahead search string resets (ms). */
+    private static readonly TYPEAHEAD_TIMEOUT;
+    private typeaheadQuery;
+    private typeaheadStamp;
+    /**
+     * APG typeahead: move focus to the next visible node whose label starts with
+     * the typed prefix. Repeating one character cycles through its matches;
+     * different characters accumulate into a search string (reset after a pause).
+     */
+    typeahead(from: StrctTreeNode, key: string): void;
     /** Toggle a node's expansion, updating state and emitting outputs. */
     toggleNode(node: StrctTreeNodeData): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTree, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTree, "strct-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "nodeMenu": { "alias": "nodeMenu"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; }, { "nodeActivated": "nodeActivated"; "nodeMenuSelect": "nodeMenuSelect"; "expandedIds": "expandedIdsChange"; "expandedChange": "expandedChange"; "nodeToggled": "nodeToggled"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTree, "strct-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "nodeMenu": { "alias": "nodeMenu"; "required": false; "isSignal": true; }; "chevronAriaLabel": { "alias": "chevronAriaLabel"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; }, { "nodeActivated": "nodeActivated"; "nodeMenuSelect": "nodeMenuSelect"; "expandedIds": "expandedIdsChange"; "expandedChange": "expandedChange"; "nodeToggled": "nodeToggled"; }, ["projectedNodes"], ["*"], true, never>;
 }
 
 /** Fixed modal width presets: sm 480 · md 640 · lg 860 · xl 1080 (px). */
@@ -1180,6 +1272,8 @@ type StrctDrawerSize = 'sm' | 'md' | 'lg';
  *   </strct-drawer>
  */
 declare class StrctDrawer {
+    private readonly elementRef;
+    private readonly doc;
     /** Open state (two-way). */
     readonly open: _angular_core.ModelSignal<boolean>;
     /** Edge to anchor to. Defaults to `end` (right in LTR). */
@@ -1190,13 +1284,26 @@ declare class StrctDrawer {
     readonly title: _angular_core.InputSignal<string>;
     /** Show the close button and allow backdrop/Esc dismissal. */
     readonly dismissable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible name of the dialog when no `title` is set (localizable). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the X close button (localizable). */
+    readonly closeLabel: _angular_core.InputSignal<string>;
     protected readonly footerDef: _angular_core.Signal<StrctDrawerFooter | undefined>;
     protected readonly hasFooter: _angular_core.Signal<boolean>;
+    /** Element that had focus before the drawer opened, restored on close. */
+    private previousActive;
+    /** Whether this instance currently holds a scroll lock. */
+    private locked;
+    constructor();
     protected onBackdrop(): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
+    /** Wrap Tab focus within the panel. */
+    protected onTab(event: Event): void;
     close(): void;
+    private panel;
+    private focusInitial;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDrawer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDrawer, "strct-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["footerDef"], ["*", "[strctDrawerFooter]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDrawer, "strct-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["footerDef"], ["*", "[strctDrawerFooter]"], true, never>;
 }
 
 /**
@@ -1296,18 +1403,43 @@ declare class StrctDropdownDivider {
  *       <strct-dropdown-item critical>Delete</strct-dropdown-item>
  *     </ng-container>
  *   </strct-context-menu>
+ *
+ * Keyboard model mirrors `StrctMenuPanel` (menu.ts): focus moves into the
+ * menu on open, Arrow/Home/End roam it, Enter/Space picks the active item,
+ * Escape closes with stopPropagation, and focus returns to the trigger.
+ *
+ * @deprecated Prefer the data-driven `[strctContextMenu]` directive backed by
+ * `StrctMenuService` (menu.ts) for new code — same visual menu, portaled into
+ * `<body>`, with submenus and item actions.
  */
 declare class StrctContextMenu {
     readonly open: _angular_core.WritableSignal<boolean>;
     readonly x: _angular_core.WritableSignal<number>;
     readonly y: _angular_core.WritableSignal<number>;
-    /** Approximate menu box used to keep it inside the viewport. */
-    private static readonly MENU_W;
-    private static readonly MENU_H;
+    protected readonly menuEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** Index within the navigable (non-disabled) items. */
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    /** Element focused before opening — focus returns here on close. */
+    private restoreTo;
     onContextMenu(event: MouseEvent): void;
     close(): void;
-    protected onDocClick(): void;
-    protected onEscape(): void;
+    /** Enabled `strct-dropdown-item` elements in DOM order. */
+    private navItems;
+    /**
+     * Focus-based roving: items keep the `tabindex="-1"` their host binding
+     * sets (so Tab never stops mid-menu), the active element moves instead.
+     */
+    protected focusItem(i: number): void;
+    /** Re-position with the measured box so the menu stays inside the viewport. */
+    private clampToViewport;
+    /** Close on a real item pick only — padding / divider misclicks keep the menu open. */
+    protected onMenuClick(event: MouseEvent): void;
+    /** Keep the arrow-key anchor in sync with the hovered item. */
+    protected onMenuMouseOver(event: MouseEvent): void;
+    protected onMenuKeydown(event: KeyboardEvent): void;
+    protected onDocClick(event: MouseEvent): void;
+    /** Fallback for focus landing outside the panel; in-panel Escape stops first. */
+    protected onEscape(event: Event): void;
     protected onResize(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctContextMenu, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctContextMenu, "strct-context-menu", never, {}, {}, never, ["*", "[strctContextMenuItems]"], true, never>;
@@ -1315,8 +1447,10 @@ declare class StrctContextMenu {
 
 /**
  * A nested fly-out inside a `strct-context-menu` or `strct-dropdown`. Opens on
- * hover, click/tap, or the keyboard (Enter / Space / →), and flips to the left
- * near the right edge of the viewport. Reuse `strct-dropdown-item` for entries.
+ * hover, click/tap, or the keyboard (Enter / Space / → — focus then moves into
+ * the fly-out, ← / Escape hand it back to the trigger), and flips to the left
+ * near the right edge of the viewport, upward near the bottom edge.
+ * Reuse `strct-dropdown-item` for entries.
  *   <strct-submenu label="Power">
  *     <strct-dropdown-item>Power on</strct-dropdown-item>
  *     <strct-dropdown-item>Power off</strct-dropdown-item>
@@ -1324,15 +1458,32 @@ declare class StrctContextMenu {
  */
 declare class StrctSubmenu {
     private readonly host;
+    private readonly trigger;
+    private readonly panel;
     /** Label text. */
     readonly label: _angular_core.InputSignal<string>;
     /** Optional leading icon; when omitted the icon column is still reserved so
      *  the label stays aligned with sibling items that do have icons. */
     readonly icon: _angular_core.InputSignal<string>;
     readonly open: _angular_core.WritableSignal<boolean>;
-    /** Open to the left when the fly-out would overflow the right edge. */
+    /** Open toward the inline start when the fly-out would overflow the inline-end edge. */
     protected readonly flip: _angular_core.WritableSignal<boolean>;
+    /** Open upward when the fly-out would overflow the bottom edge. */
+    protected readonly flipUp: _angular_core.WritableSignal<boolean>;
     protected setOpen(value: boolean): void;
+    /**
+     * Keyboard open (Enter / Space / →): focus the first fly-out entry once the
+     * panel has rendered — otherwise the fly-out is a keyboard dead end.
+     */
+    protected openFromKeyboard(): void;
+    /**
+     * APG keyboarding inside the fly-out: arrows rove, Home/End jump,
+     * ← / Escape close and hand focus back to the trigger. Handled keys stop at
+     * the panel so a host menu's own roving/Escape does not also run.
+     */
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    /** Rovable rows of the open fly-out (dropdown items, skipping disabled). */
+    private panelItems;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSubmenu, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSubmenu, "strct-submenu", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["[strctSubmenuLabel]", "*"], true, never>;
 }
@@ -1478,8 +1629,10 @@ declare class StrctDivider {
 
 /** Breadcrumb trail container. Wraps `<strct-breadcrumb-item>` children. */
 declare class StrctBreadcrumb {
+    /** Accessible label for the navigation region (localizable). */
+    readonly regionLabel: _angular_core.InputSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctBreadcrumb, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctBreadcrumb, "strct-breadcrumb", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctBreadcrumb, "strct-breadcrumb", never, { "regionLabel": { "alias": "regionLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 /** One crumb. Mark the final one `current`. */
 declare class StrctBreadcrumbItem {
@@ -1499,6 +1652,8 @@ declare class StrctPagination {
     readonly prevLabel: _angular_core.InputSignal<string>;
     readonly nextLabel: _angular_core.InputSignal<string>;
     readonly regionLabel: _angular_core.InputSignal<string>;
+    /** Label prefix for the numbered page buttons, e.g. "Page 3". */
+    readonly pageLabel: _angular_core.InputSignal<string>;
     /** Total number of items. */
     readonly total: _angular_core.InputSignal<number>;
     /** Rows per page (0 disables paging). */
@@ -1506,10 +1661,11 @@ declare class StrctPagination {
     /** Current page (two-way). */
     readonly page: _angular_core.ModelSignal<number>;
     readonly pageCount: _angular_core.Signal<number>;
+    constructor();
     protected readonly pages: _angular_core.Signal<PageToken[]>;
     go(target: number): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctPagination, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPagination, "strct-pagination", never, { "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "regionLabel": { "alias": "regionLabel"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPagination, "strct-pagination", never, { "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "regionLabel": { "alias": "regionLabel"; "required": false; "isSignal": true; }; "pageLabel": { "alias": "pageLabel"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; }, never, never, true, never>;
 }
 
 /** A leaf entry under a {@link StrctMenuSection}. */
@@ -1713,7 +1869,9 @@ declare class StrctSearchbox implements ControlValueAccessor {
 /**
  * Click-to-copy chip with built-in feedback: an icon (or icon + label) button
  * that writes `text` to the clipboard and flips to a ✓ "Copied" state for a
- * moment. The console workhorse for UUIDs, IPs, serials and snippets:
+ * moment; a failed write (rejection or insecure context) shows a localized
+ * error state instead. The console workhorse for UUIDs, IPs, serials and
+ * snippets:
  *
  *   <strct-copy text="172.16.75.100" />
  *   <strct-copy [text]="host.id" label="Copy ID" />
@@ -1729,15 +1887,19 @@ declare class StrctCopy {
     /** Localizable strings. */
     readonly copyLabel: _angular_core.InputSignal<string>;
     readonly copiedLabel: _angular_core.InputSignal<string>;
+    readonly failedLabel: _angular_core.InputSignal<string>;
     /** Emitted after a successful copy, with the copied text. */
     readonly copied: _angular_core.OutputEmitterRef<string>;
     protected readonly done: _angular_core.WritableSignal<boolean>;
+    protected readonly error: _angular_core.WritableSignal<boolean>;
     private timer;
     constructor();
     /** Write `text` to the clipboard and show the ✓ feedback. */
     copy(): void;
+    /** Surface a failed write (rejection or unavailable clipboard API). */
+    private fail;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCopy, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCopy, "strct-copy", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedLabel": { "alias": "copiedLabel"; "required": false; "isSignal": true; }; }, { "copied": "copied"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCopy, "strct-copy", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedLabel": { "alias": "copiedLabel"; "required": false; "isSignal": true; }; "failedLabel": { "alias": "failedLabel"; "required": false; "isSignal": true; }; }, { "copied": "copied"; }, never, never, true, never>;
 }
 
 /**
@@ -1774,9 +1936,11 @@ declare class StrctCode {
     /** Localizable labels for the collapse toggle. */
     readonly collapseLabel: _angular_core.InputSignal<string>;
     readonly expandLabel: _angular_core.InputSignal<string>;
+    /** Fallback accessible label when neither `title` nor `language` is set. */
+    readonly regionLabel: _angular_core.InputSignal<string>;
     protected readonly lineNos: _angular_core.Signal<number[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCode, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCode, "strct-code", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCode, "strct-code", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; "regionLabel": { "alias": "regionLabel"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, never, true, never>;
 }
 
 /** One active filter chip in a {@link StrctFilterBar}. */
@@ -1814,6 +1978,11 @@ declare class StrctFilterBar {
     readonly removed: _angular_core.OutputEmitterRef<StrctFilterChip>;
     /** "Clear filters" was clicked. */
     readonly cleared: _angular_core.OutputEmitterRef<void>;
+    private readonly host;
+    private readonly injector;
+    private readonly searchbox;
+    /** Chip × clicked: announce, then re-home the focus the removal destroys. */
+    protected removeChip(chip: StrctFilterChip, index: number): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctFilterBar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctFilterBar, "strct-filter-bar", never, { "query": { "alias": "query"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "countLabel": { "alias": "countLabel"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; }, { "query": "queryChange"; "search": "search"; "removed": "removed"; "cleared": "cleared"; }, never, ["*"], true, never>;
 }
@@ -1847,9 +2016,11 @@ declare function strctValidationIcon(status: StrctValidationStatus): string;
 declare class StrctCellStatus {
     /** The validation state to render. */
     readonly state: _angular_core.InputSignal<StrctValidationState>;
+    /** Accessible label for the 'checking' spinner (localizable). */
+    readonly loadingLabel: _angular_core.InputSignal<string>;
     protected readonly icon: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCellStatus, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCellStatus, "strct-cell-status, [strct-cell-status]", never, { "state": { "alias": "state"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCellStatus, "strct-cell-status, [strct-cell-status]", never, { "state": { "alias": "state"; "required": true; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -1914,7 +2085,9 @@ declare class StrctInput {
 /** Checkbox with custom box. Works with `[(ngModel)]` / reactive forms. */
 declare class StrctCheckbox implements ControlValueAccessor {
     readonly checked: _angular_core.ModelSignal<boolean>;
-    readonly isDisabled: _angular_core.ModelSignal<boolean>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     /** Static disable; forms' setDisabledState also drives the disabled state. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Tri-state visual indicator for a parent / intermediate state. */
@@ -1923,25 +2096,25 @@ declare class StrctCheckbox implements ControlValueAccessor {
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
     private onChange;
     protected onTouched: () => void;
-    constructor();
     onToggle(event: Event): void;
     writeValue(value: boolean): void;
     registerOnChange(fn: (value: boolean) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCheckbox, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCheckbox, "strct-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "isDisabled": "isDisabledChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCheckbox, "strct-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, never>;
 }
 
 /** On/off switch. Works with `[(ngModel)]` / reactive forms. */
 declare class StrctToggle implements ControlValueAccessor {
     readonly checked: _angular_core.WritableSignal<boolean>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     /** Static disable; forms' setDisabledState also drives the disabled state. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private onChange;
     protected onTouched: () => void;
-    constructor();
     onToggle(event: Event): void;
     writeValue(value: boolean): void;
     registerOnChange(fn: (value: boolean) => void): void;
@@ -2014,11 +2187,12 @@ declare class StrctSegmented implements ControlValueAccessor {
     /** Static disable; forms' setDisabledState also drives the disabled state. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly value: _angular_core.WritableSignal<unknown>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     private readonly segs;
     private onChange;
     protected onTouched: () => void;
-    constructor();
     protected isSelected(opt: StrctSegmentedOption): boolean;
     /** Index of the currently selected (or first enabled) option for roving focus. */
     private readonly activeIndex;
@@ -2046,14 +2220,15 @@ declare class StrctRange implements ControlValueAccessor {
     readonly step: _angular_core.InputSignal<number>;
     /** Display the current numeric value. */
     readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Static disable flag. */
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly value: _angular_core.WritableSignal<number>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly fillPercent: _angular_core.Signal<number>;
     private onChange;
     protected onTouched: () => void;
-    constructor();
     onInput(event: Event): void;
     writeValue(value: number): void;
     registerOnChange(fn: (value: number) => void): void;
@@ -2074,6 +2249,14 @@ declare class StrctPassword implements ControlValueAccessor {
     readonly meter: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Static disable flag. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Localized strength labels, weakest to strongest. */
+    readonly strengthLabels: _angular_core.InputSignal<string[]>;
+    /** aria-label of the reveal toggle when the password is hidden. */
+    readonly showLabel: _angular_core.InputSignal<string>;
+    /** aria-label of the reveal toggle when the password is visible. */
+    readonly hideLabel: _angular_core.InputSignal<string>;
+    /** Autocomplete hint; the default lets password managers work. */
+    readonly autocomplete: _angular_core.InputSignal<string>;
     readonly value: _angular_core.WritableSignal<string>;
     readonly revealed: _angular_core.WritableSignal<boolean>;
     readonly isDisabled: _angular_core.WritableSignal<boolean>;
@@ -2090,7 +2273,7 @@ declare class StrctPassword implements ControlValueAccessor {
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctPassword, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPassword, "strct-password", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "meter": { "alias": "meter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPassword, "strct-password", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "meter": { "alias": "meter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "strengthLabels": { "alias": "strengthLabels"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2104,6 +2287,12 @@ declare class StrctFile implements ControlValueAccessor {
     readonly accept: _angular_core.InputSignal<string>;
     /** Static disable flag. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Localized prompt text above the "browse" link. */
+    readonly dropLabel: _angular_core.InputSignal<string>;
+    /** Localized text of the "browse" link. */
+    readonly browseLabel: _angular_core.InputSignal<string>;
+    /** aria-label of the per-file remove button. */
+    readonly removeLabel: _angular_core.InputSignal<string>;
     readonly files: _angular_core.WritableSignal<File[]>;
     readonly dragging: _angular_core.WritableSignal<boolean>;
     readonly isDisabled: _angular_core.WritableSignal<boolean>;
@@ -2115,12 +2304,14 @@ declare class StrctFile implements ControlValueAccessor {
     remove(file: File): void;
     protected humanSize(bytes: number): string;
     private setFiles;
+    /** Keep only files matching `accept` (extension or mime pattern), like the native picker. */
+    private filterAccepted;
     writeValue(value: File[]): void;
     registerOnChange(fn: (value: File[]) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctFile, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctFile, "strct-file", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctFile, "strct-file", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dropLabel": { "alias": "dropLabel"; "required": false; "isSignal": true; }; "browseLabel": { "alias": "browseLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** Star rating input. CVA value is the selected count (0–max). */
@@ -2129,21 +2320,28 @@ declare class StrctRating implements ControlValueAccessor {
     readonly max: _angular_core.InputSignal<number>;
     /** Size variant. */
     readonly size: _angular_core.InputSignal<number>;
-    /** Prevent user interaction. */
+    /** Prevent user interaction. Stars stay focusable so AT users can read the value. */
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible name of the radiogroup. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Accessible label for each star button; receives the star index (1-based) and max. */
+    readonly starAriaLabel: _angular_core.InputSignal<(star: number, max: number) => string>;
     readonly value: _angular_core.WritableSignal<number>;
     readonly hover: _angular_core.WritableSignal<number>;
     readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    private readonly starButtons;
     protected stars(): number[];
     private onChange;
     private onTouched;
     pick(star: number): void;
+    /** Arrow keys / Home / End move focus between stars (radiogroup pattern). */
+    protected onKeydown(event: KeyboardEvent): void;
     writeValue(value: number): void;
     registerOnChange(fn: (value: number) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctRating, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRating, "strct-rating", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctRating, "strct-rating", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "starAriaLabel": { "alias": "starAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2155,7 +2353,7 @@ declare class StrctChips implements ControlValueAccessor {
     /** Placeholder text when empty. */
     readonly placeholder: _angular_core.InputSignal<string>;
     /** Allow duplicate tags. */
-    readonly allowDuplicates: _angular_core.InputSignal<boolean>;
+    readonly allowDuplicates: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly value: _angular_core.WritableSignal<string[]>;
     readonly draft: _angular_core.WritableSignal<string>;
     readonly isDisabled: _angular_core.WritableSignal<boolean>;
@@ -2163,7 +2361,7 @@ declare class StrctChips implements ControlValueAccessor {
     protected onTouched: () => void;
     onKeydown(event: KeyboardEvent): void;
     protected commitDraft(): void;
-    remove(chip: string): void;
+    remove(index: number): void;
     private emit;
     writeValue(value: string[]): void;
     registerOnChange(fn: (value: string[]) => void): void;
@@ -2183,7 +2381,7 @@ declare class StrctInputOtp implements ControlValueAccessor {
     /** Number of OTP boxes. */
     readonly length: _angular_core.InputSignal<number>;
     /** Mask each box as a password dot. */
-    readonly masked: _angular_core.InputSignal<boolean>;
+    readonly masked: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Focus box 0 on first render — the "second-factor step just appeared"
      * case, declaratively.
@@ -2256,6 +2454,8 @@ declare class StrctKnob implements ControlValueAccessor {
     private dragStartValue;
     private readonly onMove;
     private readonly onUp;
+    constructor();
+    private endDrag;
     protected onPointerDown(event: PointerEvent): void;
     protected onKeydown(event: KeyboardEvent): void;
     protected onWheel(event: WheelEvent): void;
@@ -2377,13 +2577,22 @@ declare class StrctCombobox implements ControlValueAccessor {
     readonly allowCustomValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Verb prefix of the free-form row (localizable) — renders `Use "query"`. */
     readonly customText: _angular_core.InputSignal<string>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Value identity check — override to match object values coming from a form
+     * (e.g. by id) instead of the default reference equality.
+     */
+    readonly compareWith: _angular_core.InputSignal<(a: unknown, b: unknown) => boolean>;
     readonly query: _angular_core.WritableSignal<string>;
     readonly value: _angular_core.WritableSignal<unknown>;
     /** Selection in `multiple` mode. */
     readonly values: _angular_core.WritableSignal<unknown[]>;
     readonly open: _angular_core.WritableSignal<boolean>;
     readonly activeIndex: _angular_core.WritableSignal<number>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     /** True while the user is typing a filter that hasn't been committed yet. */
     private readonly dirty;
     protected readonly filtered: _angular_core.Signal<StrctOption[]>;
@@ -2439,7 +2648,7 @@ declare class StrctCombobox implements ControlValueAccessor {
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCombobox, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCombobox, "strct-combobox", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "customText": { "alias": "customText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCombobox, "strct-combobox", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "customText": { "alias": "customText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2473,11 +2682,17 @@ declare class StrctSelect implements ControlValueAccessor {
     readonly emptyText: _angular_core.InputSignal<string>;
     /** Static disable flag (forms also drive it via setDisabledState). */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Value identity check — override to match object values coming from a form
+     * (e.g. by id) instead of the default reference equality.
+     */
+    readonly compareWith: _angular_core.InputSignal<(a: unknown, b: unknown) => boolean>;
     readonly value: _angular_core.WritableSignal<unknown>;
     readonly open: _angular_core.WritableSignal<boolean>;
     readonly activeIndex: _angular_core.WritableSignal<number>;
     readonly isDisabled: _angular_core.WritableSignal<boolean>;
     protected readonly selectedOption: _angular_core.Signal<StrctOption | undefined>;
+    protected isSelected(v: unknown): boolean;
     /** Typeahead buffer — clears half a second after the last keystroke. */
     private typed;
     private typedTimer;
@@ -2507,7 +2722,7 @@ declare class StrctSelect implements ControlValueAccessor {
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSelect, "strct-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "listLabel": { "alias": "listLabel"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSelect, "strct-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "listLabel": { "alias": "listLabel"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface DayCell {
@@ -2515,6 +2730,14 @@ interface DayCell {
     iso: string;
     inMonth: boolean;
 }
+/** Default month names, January first — the `monthNames` input default (also reused by strct-datetime-picker). */
+declare const STRCT_DP_MONTHS: string[];
+/** Default short weekday column labels, Sunday first — the `weekdayNames` input default. */
+declare const STRCT_DP_DOW: string[];
+/** Default full weekday names for accessible labels, Sunday first — the `weekdayNamesFull` input default. */
+declare const STRCT_DP_DOW_FULL: string[];
+/** Zero-pad to two digits ("4" → "04"). */
+declare const strctDpPad: (n: number) => string;
 /**
  * Calendar date picker. Value is an ISO `yyyy-mm-dd` string. CVA-compatible.
  *   <strct-datepicker [(ngModel)]="date" />
@@ -2523,18 +2746,34 @@ declare class StrctDatepicker implements ControlValueAccessor {
     private readonly host;
     /** Placeholder text when empty. */
     readonly placeholder: _angular_core.InputSignal<string>;
-    protected readonly dow: string[];
-    protected readonly dowFull: string[];
+    /** Month names, January first (localizable). */
+    readonly monthNames: _angular_core.InputSignal<string[]>;
+    /** Short weekday column labels, Sunday first (localizable). */
+    readonly weekdayNames: _angular_core.InputSignal<string[]>;
+    /** Full weekday names used in accessible labels, Sunday first (localizable). */
+    readonly weekdayNamesFull: _angular_core.InputSignal<string[]>;
+    /** First day of the week: 0 = Sunday, 1 = Monday, … 6 = Saturday. */
+    readonly weekStart: _angular_core.InputSignal<number>;
+    /** Accessible labels of the month navigation buttons (localizable). */
+    readonly prevMonthLabel: _angular_core.InputSignal<string>;
+    readonly nextMonthLabel: _angular_core.InputSignal<string>;
     protected readonly titleId: string;
     readonly value: _angular_core.WritableSignal<string>;
     readonly open: _angular_core.WritableSignal<boolean>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     /** Keyboard cursor within the open calendar. */
     readonly focusedIso: _angular_core.WritableSignal<string>;
     private readonly view;
     protected get today(): string;
     protected readonly monthLabel: _angular_core.Signal<string>;
     protected readonly displayLabel: _angular_core.Signal<string>;
+    /** Weekday column labels rotated so `weekStart` leads. */
+    protected readonly dow: _angular_core.Signal<string[]>;
+    protected readonly dowFull: _angular_core.Signal<string[]>;
     protected readonly cells: _angular_core.Signal<DayCell[]>;
     /** The 42 cells chunked into ARIA grid rows (weeks). */
     protected readonly weeks: _angular_core.Signal<DayCell[][]>;
@@ -2547,21 +2786,21 @@ declare class StrctDatepicker implements ControlValueAccessor {
     pick(iso: string): void;
     constructor();
     onKeydown(event: KeyboardEvent): void;
-    /** Day-of-week (0–6) of the keyboard cursor. */
-    private focusedDow;
+    /** Day-of-week of the keyboard cursor relative to `weekStart` (0–6). */
+    private focusedWeekOffset;
     /** Close the panel and hand focus back to the input. */
     private close;
     private syncFocus;
     private shiftFocus;
     protected onDocClick(event: MouseEvent): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     private startOfMonth;
     writeValue(value: string): void;
     registerOnChange(fn: (value: string) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDatepicker, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDatepicker, "strct-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDatepicker, "strct-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "monthNames": { "alias": "monthNames"; "required": false; "isSignal": true; }; "weekdayNames": { "alias": "weekdayNames"; "required": false; "isSignal": true; }; "weekdayNamesFull": { "alias": "weekdayNamesFull"; "required": false; "isSignal": true; }; "weekStart": { "alias": "weekStart"; "required": false; "isSignal": true; }; "prevMonthLabel": { "alias": "prevMonthLabel"; "required": false; "isSignal": true; }; "nextMonthLabel": { "alias": "nextMonthLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2575,22 +2814,28 @@ declare class StrctColorPicker implements ControlValueAccessor {
     readonly value: _angular_core.WritableSignal<string>;
     readonly draft: _angular_core.WritableSignal<string>;
     readonly open: _angular_core.WritableSignal<boolean>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     private onChange;
     private onTouched;
+    /** Where focus was when the panel opened — restored on pick/Escape. */
+    private lastFocused;
     toggle(): void;
     protected eq(color: string): boolean;
     pick(color: string): void;
     onHex(event: Event): void;
     private commit;
     protected onDocClick(event: MouseEvent): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     writeValue(value: string): void;
     registerOnChange(fn: (value: string) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctColorPicker, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctColorPicker, "strct-color-picker", never, { "swatches": { "alias": "swatches"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctColorPicker, "strct-color-picker", never, { "swatches": { "alias": "swatches"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** One option in a cascade select. */
@@ -2599,55 +2844,102 @@ interface StrctCascadeOption {
     value?: unknown;
     children?: StrctCascadeOption[];
 }
-/** DI token the nodes use to talk back to the host control (avoids a circular type). */
+/** DI token the columns use to talk back to the host control (avoids a circular type). */
 declare abstract class StrctCascadeHost {
     abstract pick(value: unknown): void;
     abstract isSelected(value: unknown): boolean;
 }
 /**
- * One row in the cascade. Leaf rows select on click; group rows reveal a
- * fly-out of their children on hover. Recurses to any depth.
+ * One column of a cascade: a flat list of rows plus at most one open fly-out
+ * column for the active group row. Recurses to any depth. Keyboard follows the
+ * menu pattern (`context-menu/menu.ts`): roving tabindex, ArrowUp/Down rove,
+ * ArrowRight opens a group's fly-out (and focuses its first row), ArrowLeft
+ * backs out, Home/End jump, Enter/Space pick or open, Escape/Tab close.
  */
-declare class StrctCascadeNode {
+declare class StrctCascadeColumn {
     private readonly host;
-    /** Option. */
-    readonly option: _angular_core.InputSignal<StrctCascadeOption>;
-    readonly open: _angular_core.WritableSignal<boolean>;
-    protected readonly hasChildren: _angular_core.Signal<boolean>;
-    protected readonly isLeafSelected: _angular_core.Signal<boolean>;
-    protected onClick(event: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCascadeNode, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCascadeNode, "strct-cascade-node", never, { "option": { "alias": "option"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    private readonly el;
+    /** Options shown in this column. */
+    readonly items: _angular_core.InputSignal<StrctCascadeOption[]>;
+    /** Rendered as a fly-out of a parent column (ArrowLeft asks the parent to close it). */
+    readonly submenu: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Focus the first row when the column appears (keyboard opens only). */
+    readonly focusOnOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted when the whole cascade should close (Escape/Tab at any depth). */
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    /** ArrowLeft at a fly-out's top level — asks the parent to close the fly-out. */
+    readonly back: _angular_core.OutputEmitterRef<void>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly openSubIndex: _angular_core.WritableSignal<number | null>;
+    /** Whether the fly-out being opened should take focus (keyboard opens only). */
+    protected subFocusOnOpen: boolean;
+    constructor();
+    protected isLeafSelected(opt: StrctCascadeOption): boolean;
+    protected focusItem(i: number): void;
+    protected closeSub(): void;
+    /** Open the active row's fly-out; keyboard opens move focus into it. */
+    private openSub;
+    private move;
+    protected onHover(i: number): void;
+    protected onLeave(i: number): void;
+    protected onItemClick(opt: StrctCascadeOption, i: number, event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCascadeColumn, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCascadeColumn, "strct-cascade-column", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; "focusOnOpen": { "alias": "focusOnOpen"; "required": false; "isSignal": true; }; }, { "close": "close"; "back": "back"; }, never, never, true, never>;
 }
 /**
  * Hierarchical single-select — pick a leaf from nested groups (e.g. a port
  * group under a virtual switch). CVA-compatible.
  *   <strct-cascade-select [options]="switches" [(ngModel)]="portGroup" />
+ *
+ * Keyboard: ArrowDown/Enter/Space open from the trigger; inside the panel
+ * arrows rove, ArrowRight opens a group's fly-out, ArrowLeft backs out,
+ * Home/End jump, Enter/Space pick a leaf, Escape/Tab close. Focus returns to
+ * the trigger on close.
  */
 declare class StrctCascadeSelect extends StrctCascadeHost implements ControlValueAccessor {
     private readonly elementRef;
     /** Available options. */
     readonly options: _angular_core.InputSignal<StrctCascadeOption[]>;
-    /** Placeholder text when empty. */
+    /** Placeholder text when empty (localizable). */
     readonly placeholder: _angular_core.InputSignal<string>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Value identity check — override to match object values coming from a form
+     * (e.g. by id) instead of the default reference equality.
+     */
+    readonly compareWith: _angular_core.InputSignal<(a: unknown, b: unknown) => boolean>;
     readonly value: _angular_core.WritableSignal<unknown>;
     readonly open: _angular_core.WritableSignal<boolean>;
-    readonly isDisabled: _angular_core.WritableSignal<boolean>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly selectedLabel: _angular_core.Signal<string>;
+    /** Element focused before the panel opened — focus returns here on close. */
+    private restoreTo;
     private onChange;
     private onTouched;
     toggle(): void;
+    openPanel(): void;
+    closePanel(): void;
+    /**
+     * ArrowDown/Enter/Space open the panel from the trigger. preventDefault so
+     * Space doesn't scroll the page and Enter/Space don't also fire the native
+     * button click (which would toggle the panel straight back shut).
+     */
+    protected onTriggerKeydown(event: KeyboardEvent): void;
     pick(value: unknown): void;
     isSelected(value: unknown): boolean;
     private findLabel;
     protected onDocClick(event: MouseEvent): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     writeValue(value: unknown): void;
     registerOnChange(fn: (value: unknown) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctCascadeSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCascadeSelect, "strct-cascade-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctCascadeSelect, "strct-cascade-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** One row in a `StrctDescriptionList` when driven by the `items` input. */
@@ -2752,11 +3044,13 @@ declare class StrctTable {
     readonly emptyText: _angular_core.InputSignal<string>;
     /** Show skeleton rows while data is loading. */
     readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible label for the scrollable region (localizable). */
+    readonly label: _angular_core.InputSignal<string>;
     private readonly cellDefs;
     private readonly cellMap;
     protected cellTemplate(key: string): TemplateRef<StrctCellContext> | null;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTable, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTable, "strct-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, ["cellDefs"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTable, "strct-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, ["cellDefs"], never, true, never>;
 }
 
 /** Every user-visible / assistive string in the grid, overridable for i18n. */
@@ -2765,7 +3059,12 @@ interface StrctDatagridLabels {
     rows: string;
     selected: string;
     selectAll: string;
+    /** Base row-checkbox label; superseded by {@link selectRowFor}, which
+     *  appends the row's identifier. Kept for existing overrides. */
     selectRow: string;
+    /** Row-checkbox label factory: receives the row's id (`rowId`) or its
+     *  1-based index, so every row's checkbox gets a distinct name. */
+    selectRowFor: (id: string) => string;
     openDetail: string;
     toggleDetail: string;
     closeDetail: string;
@@ -2924,6 +3223,7 @@ declare class StrctDatagrid {
         selected: string;
         selectAll: string;
         selectRow: string;
+        selectRowFor: (id: string) => string;
         openDetail: string;
         toggleDetail: string;
         closeDetail: string;
@@ -3003,6 +3303,12 @@ declare class StrctDatagrid {
      * hierarchically with indent + carets; sorting applies per sibling level;
      * an active filter shows matches with their ancestors, force-expanded.
      * Not combinable with `groupBy` or `lazy`.
+     *
+     * The table claims `role="treegrid"` and honors the row-level core of the
+     * treegrid keyboard contract: rows carry a roving tabindex, ArrowUp/Down
+     * move focus between rows, ArrowRight expands a collapsed parent row and
+     * ArrowLeft collapses an expanded one. There is no cell-level navigation —
+     * Tab walks the interactive elements inside each row as usual.
      */
     readonly childrenKey: _angular_core.InputSignal<string | null>;
     /** Emitted when the selection changes. */
@@ -3071,21 +3377,39 @@ declare class StrctDatagrid {
     protected readonly displayItems: _angular_core.Signal<DgItem[]>;
     protected itemKey(it: DgItem): unknown;
     protected readonly filterOpenKey: _angular_core.WritableSignal<string | null>;
+    /** The filter button that opened the panel — focus returns here on close. */
+    private filterTrigger;
     protected toggleFilterPanel(key: string, event: Event): void;
+    private closeFilterPanel;
     protected hasFilter(key: string): boolean;
     protected textFilter(key: string): string;
     protected setTextFilter(key: string, value: string): void;
     protected optionChecked(key: string, opt: unknown): boolean;
     protected toggleFilterOption(key: string, opt: unknown): void;
     protected clearFilter(key: string): void;
-    protected onDocClickFilter(event: MouseEvent): void;
-    protected onEscapeFilter(): void;
+    protected onDocClickOverlays(event: MouseEvent): void;
+    /** Escape closes the topmost transient surface and hands focus back to its
+     *  trigger; stopPropagation keeps a host modal / drawer from also closing. */
+    protected onEscapeOverlays(event: Event): void;
     private readonly expandedTree;
     protected treeDepth(row: StrctRow): number;
     protected treeHasChildren(row: StrctRow): boolean;
     protected treeExpanded(row: StrctRow): boolean;
     /** Expand / collapse one tree row. */
     toggleTreeRow(row: StrctRow): void;
+    /**
+     * Treegrid keyboard contract (row-level core; there is deliberately no
+     * cell-level navigation — Tab still walks the interactive elements inside
+     * each row): ↑/↓ move focus between rows via a roving tabindex, → expands
+     * a collapsed parent row, ← collapses an expanded one.
+     */
+    /** Roving-tabindex target (row key); defaults to the first rendered row. */
+    private readonly activeTreeRow;
+    protected treeRowTabindex(row: StrctRow): number;
+    protected onTreeRowKeydown(row: StrctRow, event: KeyboardEvent): void;
+    /** Move the roving tabindex to the row at `idx` and focus its element once
+     *  the new tabindex has rendered. */
+    private focusTreeRow;
     private readonly hostRef;
     protected readonly editing: _angular_core.WritableSignal<{
         rowKey: unknown;
@@ -3139,6 +3463,10 @@ declare class StrctDatagrid {
     protected isSticky(col: StrctDatagridColumn): boolean;
     /** The last frozen column carries the edge shadow. */
     protected readonly lastStickyKey: _angular_core.Signal<string | null>;
+    /** The rows the select-all checkbox operates on: what the user can actually
+     *  see — the current page, or every row under the expanded groups (group
+     *  mode bypasses paging, so `paged()` would silently under-select). */
+    private readonly selectionRows;
     protected readonly allPageSelected: _angular_core.Signal<boolean>;
     protected readonly somePageSelected: _angular_core.Signal<boolean>;
     /** Resolve a row's stable identity (defaults to the row object itself). */
@@ -3178,15 +3506,27 @@ declare class StrctDatagrid {
     protected sortIcon(key: string): string;
     protected ariaSort(key: string): 'ascending' | 'descending' | 'none';
     protected onHeaderSpace(event: Event, key: string): void;
+    /** The footer button that opened the column chooser — focus returns here. */
+    private chooserTrigger;
+    protected toggleChooser(event: MouseEvent): void;
+    protected closeChooser(restore?: boolean): void;
     toggleColumn(key: string, visible: boolean): void;
+    /** Distinct aria label per row checkbox: the base label + this row's
+     *  identifier (its `rowId` value, falling back to the 1-based row index). */
+    protected selectRowLabel(row: StrctRow): string;
+    private rowIdentifier;
     protected isSelected(row: StrctRow): boolean;
     protected isExpanded(row: StrctRow): boolean;
     toggleExpand(row: StrctRow): void;
     toggleRow(row: StrctRow): void;
     toggleAll(): void;
     clearSelection(): void;
-    /** Emit the current row objects whose id is selected (resolved against the
-     *  latest data, so consumers always get fresh references). */
+    /** Last known row object per selected id — selections made on one page stay
+     *  in the payload when the data set no longer contains them (lazy paging),
+     *  so `selectionChange` and `selectedCount` never disagree. */
+    private readonly selectedRowCache;
+    /** Emit every selected row: fresh objects from the latest data where
+     *  available, the last known snapshot otherwise (off-page lazy rows). */
     private commitSelection;
     private compare;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDatagrid, never>;
@@ -3202,7 +3542,7 @@ declare class StrctTimeline {
 }
 /** A timeline entry: a node on the rail plus a title and projected body. */
 declare class StrctTimelineItem {
-    /** Dialog title. */
+    /** Title shown at the top of the entry. */
     readonly title: _angular_core.InputSignal<string>;
     /** State. */
     readonly state: _angular_core.InputSignal<StrctTimelineState>;
@@ -3239,12 +3579,14 @@ declare class StrctSparkline {
     readonly width: _angular_core.InputSignal<number>;
     /** Height in pixels. */
     readonly height: _angular_core.InputSignal<number>;
+    /** Accessible name for the chart (role="img"). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     protected readonly color: _angular_core.Signal<string>;
     private readonly points;
     protected readonly linePoints: _angular_core.Signal<string>;
     protected readonly areaPoints: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSparkline, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSparkline, "strct-sparkline", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSparkline, "strct-sparkline", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** Chart rendering types (line, area, bar). */
@@ -3314,6 +3656,20 @@ interface StrctChartThreshold {
     /** Dashed line; default true. */
     dashed?: boolean;
 }
+/** Facts handed to `summaryFormat` to build the role="img" aria summary. */
+interface StrctChartSummaryInfo {
+    /** Series count (multi) or data point count (single). */
+    count: number;
+    /** Per-series label + formatted latest value (multi only). */
+    series?: {
+        label: string;
+        latest: string;
+    }[];
+    /** Formatted min / max / latest values (single-series only). */
+    min?: string;
+    max?: string;
+    latest?: string;
+}
 interface Pt {
     x: number;
     y: number;
@@ -3438,6 +3794,13 @@ declare class StrctChart {
     readonly gapText: _angular_core.InputSignal<string>;
     /** Accessible label of the reset-zoom chip (localizable). */
     readonly resetLabel: _angular_core.InputSignal<string>;
+    /** Live-mode tooltip text for the most recent point (localizable). */
+    readonly nowLabel: _angular_core.InputSignal<string>;
+    /**
+     * Factory for the role="img" aria summary (localizable); receives the
+     * computed facts. When null, a default English summary is generated.
+     */
+    readonly summaryFormat: _angular_core.InputSignal<((info: StrctChartSummaryInfo) => string) | null>;
     /** Emits the hovered point index (or null on leave) — wire cross-chart sync with it. */
     readonly hoverIndex: _angular_core.OutputEmitterRef<number | null>;
     /** Emits the brushed [startIndex, endIndex] (inclusive), or null when cleared. */
@@ -3516,6 +3879,7 @@ declare class StrctChart {
         w: number;
         h: number;
     }[]>;
+    /** Horizontal gridlines — one per y tick, so they line up with the axis labels. */
     protected readonly gridY: _angular_core.Signal<number[]>;
     private fmtAxis;
     protected readonly yAxisTicks: _angular_core.Signal<{
@@ -3562,11 +3926,11 @@ declare class StrctChart {
     protected readonly absDelta: _angular_core.Signal<number>;
     /** Second tooltip line: "Xs ago" while live, else the x label. */
     protected readonly hoverMeta: _angular_core.Signal<string>;
-    /** Per-series value at the hovered index (multi-series tooltip; bands as `avg (min–max)`). */
+    /** Per-series value at the hovered index (multi-series tooltip; bands as `avg (min–max)`).
+     *  Gap slots stay listed with `gapText`, like the single-series gap tip. */
     protected readonly hoverRows: _angular_core.Signal<{
         label: string;
         color: string;
-        value: number | null;
         text: string;
     }[]>;
     /** Per-series hover dots (multi-series). */
@@ -3622,7 +3986,7 @@ declare class StrctChart {
     /** The chart as a PNG data URL at the given scale (default 2×). */
     toPNG(scale?: number): Promise<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctChart, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctChart, "strct-chart", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "glow": { "alias": "glow"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "dots": { "alias": "dots"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "xTicks": { "alias": "xTicks"; "required": false; "isSignal": true; }; "xFormat": { "alias": "xFormat"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "yAxis": { "alias": "yAxis"; "required": false; "isSignal": true; }; "yTicks": { "alias": "yTicks"; "required": false; "isSignal": true; }; "axisFormat": { "alias": "axisFormat"; "required": false; "isSignal": true; }; "thresholds": { "alias": "thresholds"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "agoFormat": { "alias": "agoFormat"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "brush": { "alias": "brush"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "times": { "alias": "times"; "required": false; "isSignal": true; }; "gapText": { "alias": "gapText"; "required": false; "isSignal": true; }; "resetLabel": { "alias": "resetLabel"; "required": false; "isSignal": true; }; }, { "hoverIndex": "hoverIndex"; "brushChange": "brushChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctChart, "strct-chart", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "glow": { "alias": "glow"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "dots": { "alias": "dots"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "xTicks": { "alias": "xTicks"; "required": false; "isSignal": true; }; "xFormat": { "alias": "xFormat"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "yAxis": { "alias": "yAxis"; "required": false; "isSignal": true; }; "yTicks": { "alias": "yTicks"; "required": false; "isSignal": true; }; "axisFormat": { "alias": "axisFormat"; "required": false; "isSignal": true; }; "thresholds": { "alias": "thresholds"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "agoFormat": { "alias": "agoFormat"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "brush": { "alias": "brush"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "times": { "alias": "times"; "required": false; "isSignal": true; }; "gapText": { "alias": "gapText"; "required": false; "isSignal": true; }; "resetLabel": { "alias": "resetLabel"; "required": false; "isSignal": true; }; "nowLabel": { "alias": "nowLabel"; "required": false; "isSignal": true; }; "summaryFormat": { "alias": "summaryFormat"; "required": false; "isSignal": true; }; }, { "hoverIndex": "hoverIndex"; "brushChange": "brushChange"; }, never, never, true, never>;
 }
 
 /** A single weighted slice of a donut chart. */
@@ -3699,6 +4063,8 @@ declare class StrctGauge {
     readonly thresholds: _angular_core.InputSignal<StrctThresholds | null>;
     /** Label text. */
     readonly label: _angular_core.InputSignal<string>;
+    /** Accessible name for the gauge (role="meter"). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     /** Size variant. */
     readonly size: _angular_core.InputSignal<number>;
     /** Stroke thickness in pixels. */
@@ -3713,7 +4079,7 @@ declare class StrctGauge {
     protected readonly trackDash: _angular_core.Signal<string>;
     protected readonly valueDash: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctGauge, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctGauge, "strct-gauge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "thresholds": { "alias": "thresholds"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctGauge, "strct-gauge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "thresholds": { "alias": "thresholds"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** One endpoint in a `StrctFlow`. */
@@ -3798,18 +4164,27 @@ declare class StrctMetricTile {
     readonly delta: _angular_core.InputSignal<number | null>;
     /** Suffix for the delta number. */
     readonly deltaSuffix: _angular_core.InputSignal<string>;
+    /**
+     * Accessible text for the delta (rendered visually-hidden next to the number);
+     * receives the signed delta and the suffix.
+     */
+    readonly deltaAriaLabel: _angular_core.InputSignal<(delta: number, suffix: string) => string>;
     /** Treat a positive delta as bad (e.g. error rate, latency). */
     readonly invertDelta: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Skeleton placeholder + aria-busy while the metric loads. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Small sub-text under the value (e.g. "of 256 GB"). */
     readonly caption: _angular_core.InputSignal<string>;
     /** Sparkline series; empty hides the chart. */
     readonly data: _angular_core.InputSignal<number[]>;
     protected readonly hasDelta: _angular_core.Signal<boolean>;
     protected readonly absDelta: _angular_core.Signal<number>;
+    protected readonly deltaIcon: _angular_core.Signal<"minus" | "arrowUp" | "arrowDown">;
+    protected readonly deltaText: _angular_core.Signal<string>;
     protected readonly deltaTone: _angular_core.Signal<"flat" | "up" | "down">;
     protected readonly sparkStatus: _angular_core.Signal<StrctChartStatus>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctMetricTile, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctMetricTile, "strct-metric-tile", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "deltaSuffix": { "alias": "deltaSuffix"; "required": false; "isSignal": true; }; "invertDelta": { "alias": "invertDelta"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctMetricTile, "strct-metric-tile", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "deltaSuffix": { "alias": "deltaSuffix"; "required": false; "isSignal": true; }; "deltaAriaLabel": { "alias": "deltaAriaLabel"; "required": false; "isSignal": true; }; "invertDelta": { "alias": "invertDelta"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -3837,10 +4212,16 @@ declare class StrctHero {
     readonly heading: _angular_core.InputSignal<string>;
     /** Tighter padding for secondary placements. */
     readonly dense: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Opt into a polite live region (role="status") for banners whose content
+     * updates after load; static banners should leave this off. Critical heroes
+     * are always role="alert" regardless.
+     */
+    readonly live: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected readonly headingId: string;
     protected readonly resolvedIcon: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHero, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHero, "strct-hero", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "dense": { "alias": "dense"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[strctHeroMeta]", "[strctHeroActions]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHero, "strct-hero", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "dense": { "alias": "dense"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[strctHeroMeta]", "[strctHeroActions]"], true, never>;
 }
 
 /** Alert visual types. */
@@ -3867,10 +4248,11 @@ type StrctTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
  * never clipped by an ancestor's `overflow`.
  *   <button strct-button strctTooltip="More info">?</button>
  */
-declare class StrctTooltip {
+declare class StrctTooltip implements OnDestroy {
     private readonly host;
     private readonly renderer;
     private readonly doc;
+    private readonly bubbleId;
     private bubble;
     /** Tooltip text. */
     readonly strctTooltip: _angular_core.InputSignal<string>;
@@ -3878,6 +4260,9 @@ declare class StrctTooltip {
     readonly tooltipPosition: _angular_core.InputSignal<StrctTooltipPosition>;
     protected show(): void;
     protected hide(): void;
+    protected onEscape(event: Event): void;
+    protected onScroll(): void;
+    ngOnDestroy(): void;
     private place;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTooltip, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctTooltip, "[strctTooltip]", never, { "strctTooltip": { "alias": "strctTooltip"; "required": true; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -3897,14 +4282,30 @@ declare class StrctSignpost {
     private readonly host;
     /** Popover placement relative to the trigger. */
     readonly position: _angular_core.InputSignal<StrctSignpostPosition>;
+    /** Accessible name of the signpost dialog (localizable). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     readonly open: _angular_core.WritableSignal<boolean>;
+    /** Where focus was when the popover opened — restored on Escape. */
+    private lastFocused;
     toggle(): void;
-    close(): void;
+    close(restore?: boolean): void;
     protected overlayPlacement(): StrctOverlayPlacement;
     protected onDocClick(event: MouseEvent): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSignpost, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSignpost, "strct-signpost", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["[strctSignpostTrigger]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSignpost, "strct-signpost", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["[strctSignpostTrigger]", "*"], true, never>;
+}
+/**
+ * Marks (and upgrades) the signpost's trigger element. The attribute alone is
+ * enough for content projection; importing the directive additionally wires
+ * the toggle and `aria-haspopup` / `aria-expanded` onto the real button.
+ * Put it on a native `<button>`: Enter/Space then fire a single click —
+ * no keydown handlers, no double-toggle, one tab stop.
+ */
+declare class StrctSignpostTrigger {
+    protected readonly sp: StrctSignpost | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSignpostTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctSignpostTrigger, "[strctSignpostTrigger]", never, {}, {}, never, never, true, never>;
 }
 
 /** Toast visual types. */
@@ -3921,7 +4322,27 @@ interface StrctToast {
 interface StrctToastOptions {
     type?: StrctToastType;
     duration?: number;
+    /** Optional bold lead-in; kept in the history entry shown by the notification center. */
+    title?: string;
 }
+/**
+ * A persistent notification entry. Every shown toast is also recorded here
+ * (capped ring buffer) so `<strct-notification-center>` can offer a history
+ * view — toasts stay transient, the center is the persistent view. Shares the
+ * toast's `id`, so callers can correlate the two.
+ */
+interface StrctNotification {
+    id: number;
+    type: StrctToastType;
+    /** Bold lead-in; '' when the toast had no title. */
+    title: string;
+    message: string;
+    /** Epoch ms when the notification was recorded. */
+    timestamp: number;
+    read: boolean;
+}
+/** History ring-buffer capacity: only the newest entries survive a burst. */
+declare const STRCT_NOTIFICATION_HISTORY_LIMIT = 50;
 /**
  * Queues transient notifications. Render `<strct-toast-outlet />` once near the
  * app root, then call from anywhere:
@@ -3930,25 +4351,51 @@ interface StrctToastOptions {
 declare class StrctToastService {
     private counter;
     private readonly _toasts;
+    private readonly _history;
+    private readonly timers;
     readonly toasts: _angular_core.Signal<StrctToast[]>;
+    /** Persistent entries, oldest → newest, capped at STRCT_NOTIFICATION_HISTORY_LIMIT. */
+    readonly history: _angular_core.Signal<StrctNotification[]>;
+    /** Unread history entries — drives the notification-center badge. */
+    readonly unreadCount: _angular_core.Signal<number>;
     show(message: string, options?: StrctToastOptions): number;
     info(message: string, duration?: number): number;
     success(message: string, duration?: number): number;
     warning(message: string, duration?: number): number;
     critical(message: string, duration?: number): number;
+    /**
+     * Pause the auto-dismiss countdown (WCAG 2.2.1), e.g. while the toast is
+     * hovered or focus is inside it.
+     */
+    pause(id: number): void;
+    /** Resume the auto-dismiss countdown; it restarts from the full duration. */
+    resume(id: number): void;
     dismiss(id: number): void;
     clear(): void;
+    /** Flag one history entry as read (id is the one `show` returned). */
+    markRead(id: number): void;
+    /** Flag every history entry as read — empties the center's unread badge. */
+    markAllRead(): void;
+    /** Drop the whole history (transient toasts are not affected). */
+    clearHistory(): void;
+    private startTimer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToastService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<StrctToastService>;
 }
-/** Renders the toast stack. Place once, typically just inside the app shell. */
+/**
+ * Renders the toast stack, capped at the newest 5 toasts so a burst cannot
+ * grow off-viewport. Place once, typically just inside the app shell.
+ */
 declare class StrctToastOutlet {
     /** Accessible name of the notifications region (localizable). */
     readonly regionLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the dismiss button (localizable). */
+    readonly dismissLabel: _angular_core.InputSignal<string>;
     protected readonly service: StrctToastService;
+    protected readonly toasts: _angular_core.Signal<StrctToast[]>;
     protected icon(type: StrctToastType): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToastOutlet, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctToastOutlet, "strct-toast-outlet", never, { "regionLabel": { "alias": "regionLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctToastOutlet, "strct-toast-outlet", never, { "regionLabel": { "alias": "regionLabel"; "required": false; "isSignal": true; }; "dismissLabel": { "alias": "dismissLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** Preset zero/permission/error states with a sensible icon + tone. */
@@ -4078,7 +4525,10 @@ declare class StrctTimeRangePicker {
     protected readonly draftFrom: _angular_core.WritableSignal<string>;
     protected readonly draftTo: _angular_core.WritableSignal<string>;
     protected readonly draftError: _angular_core.Signal<boolean>;
+    /** Apply stays off until both drafts parse to valid, ordered dates. */
+    protected readonly applyDisabled: _angular_core.Signal<boolean>;
     protected readonly triggerLabel: _angular_core.Signal<string>;
+    constructor();
     protected pickPreset(p: StrctTimeRangePreset): void;
     protected applyAbsolute(): boolean;
     /** Re-resolve a preset range against "now" — call from your refresh tick. */
@@ -4117,7 +4567,16 @@ interface RenderLine {
  *   resumes it — the Grafana/Loki convention.
  * - **ANSI SGR colors** (16-color + bold) parsed into safe spans — no
  *   innerHTML — and severity tinting from `StrctLogLine.level` or, for plain
- *   strings, auto-detected ERROR/WARN/INFO/DEBUG tokens.
+ *   strings, auto-detected ERROR/WARN/INFO/DEBUG tokens. Non-SGR CSI
+ *   sequences (erase-in-line, cursor moves) are stripped before parsing.
+ * - **Wrap mode disables virtualization**: wrapped lines have variable
+ *   height, which fixed-height windowing cannot compute. While wrapping is
+ *   active the viewer renders all lines and sizes itself from content. Past
+ *   `WRAP_CAP` lines wrapping falls back to nowrap (virtualization stays
+ *   correct) and the wrap button exposes `wrapLimitNote` as its title.
+ * - **`role="log"`** announces streamed lines (implicit `aria-live="polite"`)
+ *   and virtualization removes off-screen lines from the a11y tree. For
+ *   follow-heavy streams set `[live]="false"` to force `aria-live="off"`.
  */
 declare class StrctLogViewer {
     /** Log lines — plain strings or `{ text, level }` objects. */
@@ -4126,14 +4585,19 @@ declare class StrctLogViewer {
     readonly height: _angular_core.InputSignal<number>;
     /** Follow the tail as new lines arrive (two-way; pauses on scroll-up). */
     readonly follow: _angular_core.ModelSignal<boolean>;
-    /** Soft-wrap long lines instead of horizontal scrolling (two-way). */
+    /** Soft-wrap long lines instead of horizontal scrolling (two-way). Disables
+     * virtualization; past `WRAP_CAP` lines it falls back to nowrap. */
     readonly wrapMode: _angular_core.ModelSignal<boolean>;
+    /** Announce streamed lines (role="log" implies aria-live="polite"). Set
+     * false on follow-heavy streams to force `aria-live="off"`. */
+    readonly live: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Auto-detect ERROR/WARN/INFO/DEBUG tokens on plain-string lines. */
     readonly autoLevel: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Localizable strings. */
     readonly title: _angular_core.InputSignal<string>;
     readonly followLabel: _angular_core.InputSignal<string>;
     readonly wrapLabel: _angular_core.InputSignal<string>;
+    readonly wrapLimitNote: _angular_core.InputSignal<string>;
     readonly linesLabel: _angular_core.InputSignal<string>;
     readonly emptyLabel: _angular_core.InputSignal<string>;
     private readonly scroller;
@@ -4141,7 +4605,15 @@ declare class StrctLogViewer {
     private suppressScrollEvent;
     private static readonly LINE_H;
     private static readonly OVERSCAN;
+    /** Max line count for which wrap mode renders all lines unvirtualized. */
+    private static readonly WRAP_CAP;
     protected readonly normalized: _angular_core.Signal<StrctLogLine[]>;
+    /** Wrapping requested but over the cap — falls back to nowrap. */
+    protected readonly wrapCapped: _angular_core.Signal<boolean>;
+    /** Wrapping actually applied: variable-height lines, virtualization off. */
+    protected readonly wrapActive: _angular_core.Signal<boolean>;
+    /** Fixed-height windowing is only valid while lines cannot wrap. */
+    protected readonly virtualized: _angular_core.Signal<boolean>;
     protected readonly totalHeight: _angular_core.Signal<number>;
     private readonly windowStart;
     protected readonly offsetY: _angular_core.Signal<number>;
@@ -4150,9 +4622,10 @@ declare class StrctLogViewer {
     protected onScroll(): void;
     protected toggleFollow(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctLogViewer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctLogViewer, "strct-log-viewer", never, { "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "follow": { "alias": "follow"; "required": false; "isSignal": true; }; "wrapMode": { "alias": "wrapMode"; "required": false; "isSignal": true; }; "autoLevel": { "alias": "autoLevel"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "followLabel": { "alias": "followLabel"; "required": false; "isSignal": true; }; "wrapLabel": { "alias": "wrapLabel"; "required": false; "isSignal": true; }; "linesLabel": { "alias": "linesLabel"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; }, { "follow": "followChange"; "wrapMode": "wrapModeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctLogViewer, "strct-log-viewer", never, { "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "follow": { "alias": "follow"; "required": false; "isSignal": true; }; "wrapMode": { "alias": "wrapMode"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "autoLevel": { "alias": "autoLevel"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "followLabel": { "alias": "followLabel"; "required": false; "isSignal": true; }; "wrapLabel": { "alias": "wrapLabel"; "required": false; "isSignal": true; }; "wrapLimitNote": { "alias": "wrapLimitNote"; "required": false; "isSignal": true; }; "linesLabel": { "alias": "linesLabel"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; }, { "follow": "followChange"; "wrapMode": "wrapModeChange"; }, never, never, true, never>;
 }
-/** Parse ANSI SGR sequences into class-tagged segments (16-color + bold). */
+/** Parse ANSI SGR sequences into class-tagged segments (16-color + bold).
+ * Non-SGR CSI sequences (ESC[K, cursor moves, …) are stripped first. */
 declare function parseAnsi(text: string): LogSegment[];
 
 /** One row of a computed line diff. */
@@ -4224,7 +4697,9 @@ declare class StrctDiff {
     protected readonly splitRows: _angular_core.Signal<AnySplitRow[]>;
     /** Group rows into visible chunks and collapsible unchanged runs. */
     private readonly chunks;
-    protected expand(startIndex: number): void;
+    constructor();
+    protected isExpanded(startIndex: number): boolean;
+    protected toggle(startIndex: number): void;
     protected sign(type: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDiff, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDiff, "strct-diff", never, { "before": { "alias": "before"; "required": true; "isSignal": true; }; "after": { "alias": "after"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "beforeLabel": { "alias": "beforeLabel"; "required": false; "isSignal": true; }; "afterLabel": { "alias": "afterLabel"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "copyAfterLabel": { "alias": "copyAfterLabel"; "required": false; "isSignal": true; }; "unchangedLabel": { "alias": "unchangedLabel"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -4250,18 +4725,22 @@ declare class StrctSplitter {
     readonly min: _angular_core.InputSignal<number>;
     readonly max: _angular_core.InputSignal<number>;
     /** Stack panes vertically (gutter drags up/down). */
-    readonly vertical: _angular_core.InputSignal<boolean>;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Accessible name of the separator (localizable). */
     readonly gutterLabel: _angular_core.InputSignal<string>;
     /** Keyboard nudge step in percent. */
     readonly step: _angular_core.InputSignal<number>;
     protected readonly clamped: _angular_core.Signal<number>;
-    protected dragging: boolean;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
     private moveHandler;
     private upHandler;
-    protected onDragStart(event: MouseEvent): void;
+    constructor();
+    protected onDragStart(event: PointerEvent): void;
     private onDragMove;
     private onDragEnd;
+    private removeDragListeners;
+    /** Document direction — pointer coordinates and arrow keys are physical, panes are logical. */
+    private isRtl;
     protected onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctSplitter, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctSplitter, "strct-splitter", never, { "split": { "alias": "split"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "gutterLabel": { "alias": "gutterLabel"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "split": "splitChange"; }, never, ["[strctPaneStart]", "[strctPaneEnd]"], true, never>;
@@ -4385,11 +4864,14 @@ interface StrctTourStep {
  *   <strct-tour [(open)]="tourOpen" [steps]="steps" (finished)="done()" />
  *
  * Each step spotlights its `target` selector with a ring cut out of a dimmed
- * backdrop and anchors a card next to it. Arrows / buttons step, Escape
- * closes, and the card is a labeled dialog. Purely DOM-driven: targets are
- * looked up when the step shows, so it works over any page.
+ * backdrop and anchors a card next to it. Arrows (mirrored in RTL) / buttons
+ * step, Home/End jump to the ends, Escape closes, and the card is a labeled
+ * dialog: focus moves into it (Tab is trapped) and returns to the trigger on
+ * close. Purely DOM-driven: targets are looked up when the step shows, so it
+ * works over any page.
  */
 declare class StrctTour {
+    private readonly elementRef;
     /** Whether the tour is showing (two-way). */
     readonly open: _angular_core.ModelSignal<boolean>;
     /** The steps, in order. */
@@ -4405,6 +4887,9 @@ declare class StrctTour {
     protected readonly index: _angular_core.WritableSignal<number>;
     /** Bumped on open/step/resize to re-measure the target. */
     private readonly measureTick;
+    protected readonly titleId: string;
+    /** Element that had focus before the tour opened, restored on close. */
+    private previousActive;
     protected readonly current: _angular_core.Signal<StrctTourStep>;
     protected readonly spot: _angular_core.Signal<{
         top: number;
@@ -4420,8 +4905,22 @@ declare class StrctTour {
     protected next(): void;
     protected prev(): void;
     protected close(): void;
+    /** Wrap Tab focus within the card. */
+    protected onTab(event: Event): void;
+    /** Escape closes; stopPropagation so a host modal/drawer does not also close. */
+    protected onEscapeKey(event: Event): void;
+    /**
+     * Arrow keys step through the tour, mirrored under RTL. No shared direction
+     * helper exists (other components handle RTL in CSS only), so read the
+     * card's computed direction here.
+     */
+    protected onArrow(event: Event, dir: 'left' | 'right'): void;
+    /** Home/End jump to the first/last step. */
+    protected onHomeEnd(event: Event, last: boolean): void;
     private scrollToTarget;
-    protected onEscape(): void;
+    private card;
+    /** Move focus to the step's primary (Next/Done) action once the card has rendered. */
+    private focusNextButton;
     protected onReflow(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTour, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTour, "strct-tour", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "backLabel": { "alias": "backLabel"; "required": false; "isSignal": true; }; "skipLabel": { "alias": "skipLabel"; "required": false; "isSignal": true; }; "doneLabel": { "alias": "doneLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "finished": "finished"; "dismissed": "dismissed"; }, never, never, true, never>;
@@ -4439,9 +4938,11 @@ interface StrctMenubarItem {
  *
  *   <strct-menubar [menus]="menus" (picked)="run($event)" />
  *
- * Click (or Enter/Down) opens a menu; Left/Right move across the bar and,
- * while open, switch the open menu (the APG menubar convention). Escape and
- * outside click close. `(picked)` carries `{ menu, item }`.
+ * Click (or Enter/Down) opens a menu and focus moves into it; Left/Right move
+ * across the bar and, while open, switch the open menu (the APG menubar
+ * convention). Up/Down (+Home/End) rove the open menu, Right/Left enter and
+ * leave an item's one-level `children` submenu. Escape and outside click
+ * close, returning focus to the bar. `(picked)` carries `{ menu, item }`.
  */
 declare class StrctMenubar {
     private readonly host;
@@ -4456,11 +4957,24 @@ declare class StrctMenubar {
     }>;
     protected readonly openId: _angular_core.WritableSignal<string | null>;
     protected readonly focusIdx: _angular_core.WritableSignal<number>;
+    /** Index of the item whose one-level submenu is open. */
+    protected readonly subIdx: _angular_core.WritableSignal<number | null>;
+    /** Top-level button that opened the menu — focus returns here on close. */
+    private trigger;
     protected toggleMenu(id: string, i: number): void;
+    protected onItemClick(menu: StrctMenubarItem, item: StrctMenuItem, i: number): void;
+    protected onItemHover(item: StrctMenuItem, i: number): void;
     protected pick(menu: StrctMenubarItem, item: StrctMenuItem): void;
     protected onTopKey(event: KeyboardEvent, i: number): void;
+    protected onMenuKey(event: KeyboardEvent, menu: StrctMenubarItem): void;
+    /** Switch the open menu to the next/previous top-level entry; focus follows. */
+    private switchTop;
+    private closeMenu;
+    private topButtons;
+    /** Enabled item buttons of the open menu — either its items or the open submenu's. */
+    private navButtons;
     protected onDocClick(event: MouseEvent): void;
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctMenubar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctMenubar, "strct-menubar", never, { "menus": { "alias": "menus"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "picked": "picked"; }, never, never, true, never>;
 }
@@ -4477,7 +4991,8 @@ declare class StrctMenubar {
  */
 declare class StrctAnnouncer implements OnDestroy {
     private regions;
-    private clearTimer;
+    private clearTimers;
+    private readonly isBrowser;
     announce(message: string, politeness?: 'polite' | 'assertive'): void;
     private regionFor;
     ngOnDestroy(): void;
@@ -4487,7 +5002,7 @@ declare class StrctAnnouncer implements OnDestroy {
 
 /** A registered application hotkey. */
 interface StrctHotkey {
-    /** Combo like `'ctrl+k'`, `'meta+shift+p'`, `'?'` — `mod` = Ctrl/⌘. */
+    /** Combo like `'ctrl+k'`, `'meta+shift+p'`, `'shift+?'` — `mod` = Ctrl/⌘. */
     combo: string;
     /** Human description shown in the help overlay. */
     description: string;
@@ -4504,7 +5019,7 @@ interface StrctHotkey {
  *     { combo: 'mod+k', description: 'Open command palette', group: 'Global',
  *       handler: () => this.palette.open() }); }
  *
- * Combos: `'a'`, `'?'`, `'ctrl+k'`, `'meta+shift+p'`, `'mod+k'` (mod = Ctrl/⌘).
+ * Combos: `'a'`, `'shift+?'`, `'ctrl+k'`, `'meta+shift+p'`, `'mod+k'` (mod = Ctrl/⌘).
  * Plain-key combos are suppressed while typing in inputs / textareas /
  * contenteditable; modifier combos always fire. Pair with
  * `<strct-hotkeys-help/>` for the ⌘/ ("?") cheatsheet overlay.
@@ -4524,26 +5039,31 @@ declare class StrctHotkeysService implements OnDestroy {
 }
 /**
  * The hotkey cheatsheet overlay. Mount once near the app root; it registers
- * `?` itself and lists everything in the service, grouped:
+ * `shift+?` (typed as `?`) itself and lists everything in the service, grouped:
  *
  *   <strct-hotkeys-help />
  */
 declare class StrctHotkeysHelp {
     private readonly service;
+    private readonly host;
     /** Overlay visibility (two-way; `?` toggles it too). */
     readonly open: _angular_core.ModelSignal<boolean>;
     /** Localizable strings. */
     readonly title: _angular_core.InputSignal<string>;
     readonly emptyText: _angular_core.InputSignal<string>;
+    /** Accessible label of the × close button (localizable). */
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    /** Element that had focus before the overlay opened, restored on close. */
+    private previousActive;
     protected readonly grouped: _angular_core.Signal<{
         name: string;
         keys: StrctHotkey[];
     }[]>;
     constructor();
-    protected onEscape(): void;
+    protected onEscape(event: Event): void;
     protected parts(combo: string): string[];
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHotkeysHelp, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHotkeysHelp, "strct-hotkeys-help", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHotkeysHelp, "strct-hotkeys-help", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
 }
 
 /** A completed reorder: move the item at `from` to `to` in your array. */
@@ -4567,20 +5087,43 @@ interface StrctReorderEvent {
  * Items are HTML5-draggable; keyboard reorder is Alt+ArrowUp / Alt+ArrowDown
  * on the focused item (items get `tabindex="0"` unless they already manage
  * focus). Indexes are positions among the `strctReorderItem` siblings.
+ * Completed moves are announced in a live region (see `announcement`) and
+ * items reference the sr-only `instructions` via `aria-describedby`.
  */
-declare class StrctReorder {
+declare class StrctReorder implements OnDestroy {
     private readonly host;
+    private readonly renderer;
+    private readonly doc;
+    private readonly announcer;
     /** Emits when a drag or keyboard move completes. */
     readonly reordered: _angular_core.OutputEmitterRef<StrctReorderEvent>;
     /** Disable all reordering (display-only mode). */
-    readonly reorderDisabled: _angular_core.InputSignal<boolean>;
+    readonly reorderDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Keyboard instructions (localizable), rendered sr-only and referenced by
+     * every item's `aria-describedby`. Set to '' to opt out.
+     */
+    readonly instructions: _angular_core.InputSignal<string>;
+    /**
+     * Builds the live-region announcement after a move (localizable):
+     * (moved item's text, new 1-based position, item count).
+     */
+    readonly announcement: _angular_core.InputSignal<(label: string, position: number, total: number) => string>;
     readonly dragIndex: _angular_core.WritableSignal<number | null>;
     readonly overIndex: _angular_core.WritableSignal<number | null>;
+    /** Id of the sr-only instructions element the items point to. */
+    readonly instructionsId: string;
+    private hint;
+    constructor();
     items(): HTMLElement[];
     indexOf(el: HTMLElement): number;
     commit(from: number, to: number): void;
+    protected onContainerDragOver(event: DragEvent): void;
+    protected onContainerDrop(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctReorder, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctReorder, "[strctReorder]", never, { "reorderDisabled": { "alias": "reorderDisabled"; "required": false; "isSignal": true; }; }, { "reordered": "reordered"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctReorder, "[strctReorder]", never, { "reorderDisabled": { "alias": "reorderDisabled"; "required": false; "isSignal": true; }; "instructions": { "alias": "instructions"; "required": false; "isSignal": true; }; "announcement": { "alias": "announcement"; "required": false; "isSignal": true; }; }, { "reordered": "reordered"; }, never, never, true, never>;
 }
 /** One draggable row inside a `[strctReorder]` container. */
 declare class StrctReorderItem {
@@ -4590,7 +5133,7 @@ declare class StrctReorderItem {
     protected hostTabindex(): number | null;
     protected isDragging(): boolean;
     protected isOver(): boolean;
-    private index;
+    protected index(): number;
     protected onDragStart(event: DragEvent): void;
     protected onDragOver(event: DragEvent): void;
     protected onDrop(event: DragEvent): void;
@@ -4600,5 +5143,633 @@ declare class StrctReorderItem {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctReorderItem, "[strctReorderItem]", never, {}, {}, never, never, true, never>;
 }
 
-export { STRCT_ICONS, STRCT_ICON_GROUPS, STRCT_ICON_NAMES, STRCT_MASKS, STRCT_PALETTES, STRCT_RAW_ICONS, STRCT_TIME_RANGE_PRESETS, STRCT_WIZARD_DEFAULTS, StrctAccordion, StrctAccordionPanel, StrctAlert, StrctAnnouncer, StrctAvatar, StrctBadge, StrctBreadcrumb, StrctBreadcrumbItem, StrctButton, StrctButtonGroup, StrctBytesPipe, StrctCard, StrctCardBlock, StrctCardFooter, StrctCardHeader, StrctCascadeHost, StrctCascadeNode, StrctCascadeSelect, StrctCellDef, StrctCellStatus, StrctChart, StrctCheckbox, StrctChips, StrctCode, StrctColorPicker, StrctCombobox, StrctCommandPalette, StrctContextMenu, StrctContextMenuTrigger, StrctCopy, StrctDatagrid, StrctDatagridActionBar, StrctDatepicker, StrctDesc, StrctDescriptionList, StrctDiff, StrctDivider, StrctDonut, StrctDrawer, StrctDrawerFooter, StrctDropdown, StrctDropdownDivider, StrctDropdownItem, StrctDropdownTrigger, StrctDurationPipe, StrctEmptyState, StrctField, StrctFile, StrctFilterBar, StrctFlow, StrctFooter, StrctGauge, StrctHeader, StrctHero, StrctHotkeysHelp, StrctHotkeysService, StrctIcon, StrctInput, StrctInputMask, StrctInputOtp, StrctKbd, StrctKnob, StrctLogViewer, StrctLogin, StrctMenuPanel, StrctMenuService, StrctMenubar, StrctMetricTile, StrctModal, StrctNav, StrctNavItem, StrctOverlay, StrctPageHeader, StrctPageHeaderActions, StrctPageHeaderCrumbs, StrctPagination, StrctPassword, StrctProgress, StrctRadio, StrctRadioGroup, StrctRail, StrctRange, StrctRatePipe, StrctRating, StrctReorder, StrctReorderItem, StrctRowDetailDef, StrctSearchbox, StrctSectionMenu, StrctSegmented, StrctSelect, StrctShell, StrctShellService, StrctSiPipe, StrctSignpost, StrctSkeleton, StrctSparkline, StrctSpeedDial, StrctSpinner, StrctSplitButton, StrctSplitter, StrctStack, StrctStackItem, StrctStep, StrctSubmenu, StrctTab, StrctTable, StrctTabs, StrctTag, StrctThemeService, StrctThemeSwitcher, StrctTimeRangePicker, StrctTimeline, StrctTimelineItem, StrctToastOutlet, StrctToastService, StrctToggle, StrctTooltip, StrctTour, StrctTransfer, StrctTree, StrctTreeNode, StrctVerticalNav, StrctWatermark, StrctWizard, StrctWizardAside, parseAnsi, provideStrctWizardDefaults, registerStrctIcon, strctComputeDiff, strctFormatBytes, strctFormatDuration, strctFormatRate, strctFormatSi, strctValidationIcon, strctValidationTone };
-export type { StrctAlertType, StrctAvatarSize, StrctAvatarStatus, StrctBadgeStatus, StrctButtonSize, StrctButtonVariant, StrctCascadeOption, StrctCellContext, StrctChartAnnotation, StrctChartColor, StrctChartCurve, StrctChartSeries, StrctChartSlot, StrctChartStatus, StrctChartThreshold, StrctChartType, StrctColumn, StrctCommandItem, StrctDatagridColumn, StrctDatagridColumnState, StrctDatagridFilters, StrctDatagridLabels, StrctDatagridLazyState, StrctDescAlign, StrctDescItem, StrctDiffRow, StrctDonutSegment, StrctDrawerSide, StrctDrawerSize, StrctEmptyVariant, StrctFilterChip, StrctFlowDirection, StrctFlowNode, StrctFlowOrientation, StrctHotkey, StrctIconBadge, StrctIconName, StrctKnobStatus, StrctLogLine, StrctMenuItem, StrctMenuLink, StrctMenuOpenOptions, StrctMenuSection, StrctMenubarItem, StrctMetricStatus, StrctModalSize, StrctMode, StrctOption, StrctOverlayPlacement, StrctPalette, StrctPaletteInfo, StrctProgressStatus, StrctRailItem, StrctRailStatus, StrctReorderEvent, StrctRow, StrctRowId, StrctSegmentedOption, StrctSegmentedSize, StrctSignpostPosition, StrctSpeedDialDirection, StrctSpinnerSize, StrctStatus, StrctTagStatus, StrctThresholds, StrctTimeRange, StrctTimeRangePreset, StrctTimelineState, StrctToast, StrctToastOptions, StrctToastType, StrctTooltipPosition, StrctTourStep, StrctTransferItem, StrctTreeMenuEvent, StrctTreeNodeData, StrctTreeNodeMenuFn, StrctValidationState, StrctValidationStatus, StrctWizardDefaults };
+/**
+ * Shared focus-lifecycle helpers for transient overlay surfaces (tooltip,
+ * drawer, menus, popovers …): remember the trigger before opening, move
+ * focus in on open, cycle Tab inside, and hand focus back on close.
+ * Modeled on the modal's local implementation (`modal/modal.ts`).
+ */
+/** Elements considered tabbable inside an overlay, queried in DOM order. */
+declare const FOCUSABLE_SELECTOR = "a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex=\"-1\"])";
+/** Currently focused element, if it is an HTMLElement (remember the trigger before opening). */
+declare function saveFocusedElement(): HTMLElement | null;
+/** Focus `el` again if it is still in the document; null-safe. */
+declare function restoreFocus(el: HTMLElement | null | undefined): void;
+/**
+ * Focus the first tabbable descendant of `container`.
+ * Returns whether something was focused; with nothing tabbable the container
+ * itself is NOT focused — the caller decides the fallback.
+ */
+declare function focusFirstIn(container: HTMLElement): boolean;
+/**
+ * Tab trap for modal-ish overlays: cycle Tab/Shift+Tab within the
+ * container's tabbable descendants, wrapping at both ends (preventDefault
+ * when it wraps). Wire it to the container's `keydown.tab` /
+ * `keydown.shift.tab` events.
+ */
+declare function keepTabInside(event: KeyboardEvent, container: HTMLElement): void;
+
+/** Acquire a scroll lock: hides body overflow on the first acquisition. */
+declare function lockBodyScroll(doc: Document): void;
+/** Release a scroll lock: restores the saved body overflow on the last release. */
+declare function unlockBodyScroll(doc: Document): void;
+
+/** Dot sizes: `sm` for dense rows (tables, menus), `md` standalone. */
+type StrctStatusDotSize = 'sm' | 'md';
+/**
+ * Presence/state dot that never relies on colour alone: the tone is painted by
+ * a pure-CSS dot while the state is also rendered as visually-hidden text, so
+ * screen readers (and colour-blind users copying text) get "Warning", not just
+ * a yellow circle. Use it inside avatars, menu rows, metric tiles — anywhere a
+ * bare coloured dot would otherwise carry meaning.
+ *
+ *   <strct-status-dot status="success" />
+ *   <strct-status-dot status="critical" size="sm" label="Node unreachable" />
+ */
+declare class StrctStatusDot {
+    /** Status tone (canonical vocabulary: OK = 'success', info = 'accent'). */
+    readonly status: _angular_core.InputSignal<StrctStatus>;
+    /**
+     * Accessible text describing the state (localizable). Empty falls back to a
+     * per-status default ("OK", "Warning", …) so the dot is never color-only.
+     */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Dot size: `sm` for dense rows, `md` standalone. */
+    readonly size: _angular_core.InputSignal<StrctStatusDotSize>;
+    protected readonly text: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctStatusDot, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctStatusDot, "strct-status-dot", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Numeric stepper input: − / + buttons flanking a text field. The value is
+ * `number | null` (null = empty); typing is free-form (intermediate states
+ * like "-" are kept), committed values clamp to `min`/`max` on blur, and the
+ * buttons + keyboard always clamp immediately.
+ *
+ *   <strct-number [min]="0" [max]="64" [step]="4" [(ngModel)]="vcpus" />
+ *
+ * Keyboard on the field: ArrowUp/Down ±step, PageUp/Down ±10×step,
+ * Home/End jump to min/max. The field exposes `role="spinbutton"` with
+ * aria-valuemin/max/now so assistive tech announces it as a number control.
+ */
+declare class StrctNumber implements ControlValueAccessor {
+    /** Minimum allowed value; null = unbounded. */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Maximum allowed value; null = unbounded. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Step increment for buttons and Arrow keys (PageUp/Down use 10×). */
+    readonly step: _angular_core.InputSignal<number>;
+    /** Placeholder text when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Accessible label of the + button (localizable). */
+    readonly incrementLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the − button (localizable). */
+    readonly decrementLabel: _angular_core.InputSignal<string>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<number | null>;
+    /** Raw field text — may hold an unparseable intermediate state while typing. */
+    protected readonly text: _angular_core.WritableSignal<string>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** At/below min (or min unset → never) — greys out the − button. */
+    protected readonly atMin: _angular_core.Signal<boolean>;
+    /** At/above max (or max unset → never) — greys out the + button. */
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    private onChange;
+    protected onTouched: () => void;
+    protected onInput(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Commit the pending text on blur: parse, clamp, restore on garbage. */
+    protected onBlur(): void;
+    /** Button / keyboard step: an empty field first lands on min (or 0). */
+    protected stepBy(dir: 1 | -1, factor?: number): void;
+    private commitTo;
+    private clamp;
+    /** Trim float dust from step arithmetic (0.1 + 0.2), not a grid snap. */
+    private snap;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctNumber, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctNumber, "strct-number", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "incrementLabel": { "alias": "incrementLabel"; "required": false; "isSignal": true; }; "decrementLabel": { "alias": "decrementLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A generic anchored overlay panel for arbitrary projected content — the
+ * public primitive behind menus, signposts and rich pickers:
+ *   <strct-popover placement="bottom-end" ariaLabel="More actions">
+ *     <button strct-button strctPopoverTrigger>Actions</button>
+ *     <p>Any content — text, lists or controls…</p>
+ *   </strct-popover>
+ *
+ * `open` is two-way, so the panel can also be driven from the outside:
+ *   <strct-popover [(open)]="show">…</strct-popover>
+ *
+ * Positioning, edge-flip and scroll/resize tracking come from StrctOverlay;
+ * the panel is `position: fixed`, so it escapes ancestor overflow clipping.
+ */
+declare class StrctPopover {
+    private readonly host;
+    private readonly panelRef;
+    /** Whether the panel is open (two-way). */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Panel placement relative to the trigger; edge-flip is automatic. */
+    readonly placement: _angular_core.InputSignal<StrctOverlayPlacement>;
+    /** Accessible name of the popover dialog (localizable). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Modal-ish usage: move focus into the panel on open, trap Tab inside and
+     * hand focus back to the trigger on close. Off by default — a plain popover
+     * never steals focus and Tab moves on freely.
+     */
+    readonly trap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Where focus was when the panel opened — restored on Escape / trap close. */
+    private lastFocused;
+    constructor();
+    toggle(): void;
+    close(restore?: boolean): void;
+    /** Wrap Tab within the panel in trap mode; a no-op otherwise. */
+    protected onTab(event: Event): void;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctPopover, "strct-popover", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "trap": { "alias": "trap"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["[strctPopoverTrigger]", "*"], true, never>;
+}
+/**
+ * Marks (and upgrades) the popover's trigger element. The attribute alone is
+ * enough for content projection; importing the directive additionally wires
+ * the toggle and `aria-haspopup` / `aria-expanded` onto the real button.
+ * Put it on a native `<button>`: Enter/Space then fire a single click —
+ * no keydown handlers, no double-toggle, one tab stop.
+ */
+declare class StrctPopoverTrigger {
+    protected readonly popover: StrctPopover | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctPopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StrctPopoverTrigger, "[strctPopoverTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/** Confirm-dialog tone: `critical` styles the confirm button as destructive. */
+type StrctConfirmTone = 'default' | 'critical';
+/** Options passed when asking for confirmation. */
+interface StrctConfirmOptions {
+    /** Dialog title. */
+    title: string;
+    /** Body text spelling out the consequences. */
+    message: string;
+    /** Confirm button label — falls back to the outlet's `confirmLabel`. */
+    confirmLabel?: string;
+    /** Cancel button label — falls back to the outlet's `cancelLabel`. */
+    cancelLabel?: string;
+    /** `critical` renders the confirm button in the destructive tone. */
+    tone?: StrctConfirmTone;
+}
+/** A pending confirmation, with its promise resolver attached. */
+interface StrctConfirmRequest extends StrctConfirmOptions {
+    resolve: (ok: boolean) => void;
+}
+/**
+ * Promise-based confirmation for destructive actions. Render
+ * `<strct-confirm-outlet />` once near the app root, then await from anywhere:
+ *   if (await inject(StrctConfirmService).confirm({ title: 'Delete row?', message: '…', tone: 'critical' })) { … }
+ */
+declare class StrctConfirmService {
+    private readonly _active;
+    /** The confirmation currently on screen, if any. */
+    readonly active: _angular_core.Signal<StrctConfirmRequest | null>;
+    /**
+     * Ask the user to confirm; resolves `true` on confirm, `false` on cancel,
+     * the X, Escape or a backdrop click. One dialog at a time — a new call
+     * cancels (resolves `false`) the pending one.
+     */
+    confirm(options: StrctConfirmOptions): Promise<boolean>;
+    /** Resolve the pending confirmation and close the dialog. */
+    settle(result: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctConfirmService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StrctConfirmService>;
+}
+/**
+ * Renders the active confirmation as a small strct-modal (focus trap, Escape /
+ * backdrop dismissal and focus restore included). Place once, typically just
+ * inside the app shell. The default labels are inputs, so an app can localize
+ * every confirm() call in one place.
+ */
+declare class StrctConfirmOutlet {
+    /** Default confirm button label (localizable). */
+    readonly confirmLabel: _angular_core.InputSignal<string>;
+    /** Default cancel button label (localizable). */
+    readonly cancelLabel: _angular_core.InputSignal<string>;
+    /** Accessible label of the X close button (localizable). */
+    readonly closeLabel: _angular_core.InputSignal<string>;
+    protected readonly service: StrctConfirmService;
+    protected readonly req: _angular_core.Signal<StrctConfirmRequest | null>;
+    private readonly host;
+    /** The request the safe-default focus was already applied for. */
+    private focusedFor;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctConfirmOutlet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctConfirmOutlet, "strct-confirm-outlet", never, { "confirmLabel": { "alias": "confirmLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Tree picker in a dropdown: a trigger button wearing the shared
+ * `.strct-control` look opens an overlay panel hosting the data-driven
+ * `<strct-tree>`. CVA-compatible single-select of a node key (`id`, falling
+ * back to `label` — the same key the tree uses for `expandedIds`); the
+ * trigger shows the selected node's full label path (`Parent / Child`).
+ *
+ *   <strct-tree-select [nodes]="tree" [(ngModel)]="nodeId" clearable />
+ *
+ * Keyboard: ArrowDown/Enter/Space open from the trigger; inside the panel the
+ * tree's own ARIA pattern applies (arrows rove, Right/Left expand/collapse,
+ * typeahead jumps, Enter picks). Escape closes (stopPropagation, so a host
+ * modal/drawer stays open); focus returns to the trigger on close.
+ */
+declare class StrctTreeSelect implements ControlValueAccessor {
+    private readonly host;
+    /** Root nodes rendered by the embedded `<strct-tree>` (data-driven mode). */
+    readonly nodes: _angular_core.InputSignal<StrctTreeNodeData[]>;
+    /** Placeholder text when empty (localizable). */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Show an × that resets the selection. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text shown when `nodes` is empty (localizable). */
+    readonly emptyText: _angular_core.InputSignal<string>;
+    /** Accessible label of the × clear button (localizable). */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<string | null>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    /**
+     * Expansion state handed to the tree (controlled). Seeded with the selected
+     * node's ancestors on open so the current pick is visible; afterwards owned
+     * by the tree through the two-way binding.
+     */
+    readonly expandedIds: _angular_core.WritableSignal<string[] | null>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Element focused before the panel opened — focus returns here on close. */
+    private restoreTo;
+    private onChange;
+    private onTouched;
+    /** Stable key for a node: its `id`, or the `label` as a fallback (tree idiom). */
+    private keyOf;
+    /** The tree data with `active` flagged on the selected node (highlight + focus target). */
+    protected readonly displayNodes: _angular_core.Signal<StrctTreeNodeData[]>;
+    /** Full label path of the selected node, joined with ` / ` ("Parent / Child"). */
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    /** Chain of nodes from a root down to the node with key `v` (null when absent). */
+    private findPath;
+    toggle(): void;
+    openPanel(): void;
+    closePanel(): void;
+    /**
+     * ArrowDown/Enter/Space open the panel from the trigger. preventDefault so
+     * Space doesn't scroll the page and Enter/Space don't also fire the native
+     * button click (which would toggle the panel straight back shut).
+     */
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    /** Escape inside the panel (the tree's rows don't handle it themselves). */
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    /** Commit a node pick: its key becomes the value and the panel closes. */
+    pick(node: StrctTreeNodeData): void;
+    protected clear(event: Event): void;
+    protected onDocClick(event: MouseEvent): void;
+    protected onEscape(event: Event): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctTreeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctTreeSelect, "strct-tree-select", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Date + time in one control — a thin composition over the existing
+ * `<strct-datepicker>` (calendar, keyboard grid, focus lifecycle and Escape
+ * handling included) plus hour/minute selects, sharing one `.strct-control`
+ * field skin. The value is an ISO local datetime string `YYYY-MM-DDTHH:mm`;
+ * CVA-compatible.
+ *
+ *   <strct-datetime-picker [(ngModel)]="stamp" [minuteStep]="15" />
+ *
+ * The calendar localization inputs (`monthNames`, `weekdayNames`,
+ * `weekdayNamesFull`, `weekStart`, `prevMonthLabel`, `nextMonthLabel`) are
+ * passed straight through to the embedded datepicker. Picking a time before a
+ * date keeps the value empty until a date is picked.
+ */
+declare class StrctDatetimePicker implements ControlValueAccessor {
+    /** Placeholder text of the date input when empty (localizable). */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Minute granularity of the minute select (1 = every minute). */
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    /** Calendar localization — passed straight through to the embedded datepicker. */
+    readonly monthNames: _angular_core.InputSignal<string[]>;
+    readonly weekdayNames: _angular_core.InputSignal<string[]>;
+    readonly weekdayNamesFull: _angular_core.InputSignal<string[]>;
+    /** First day of the week: 0 = Sunday, 1 = Monday, … 6 = Saturday. */
+    readonly weekStart: _angular_core.InputSignal<number>;
+    readonly prevMonthLabel: _angular_core.InputSignal<string>;
+    readonly nextMonthLabel: _angular_core.InputSignal<string>;
+    /** Accessible labels of the time selects (localizable). */
+    readonly hourLabel: _angular_core.InputSignal<string>;
+    readonly minuteLabel: _angular_core.InputSignal<string>;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The composed ISO value (`YYYY-MM-DDTHH:mm`, '' when no date is picked). */
+    readonly value: _angular_core.WritableSignal<string>;
+    /** Date part, two-way bound into the embedded datepicker. */
+    readonly date: _angular_core.WritableSignal<string>;
+    /** Time parts (zero-padded). */
+    readonly hour: _angular_core.WritableSignal<string>;
+    readonly minute: _angular_core.WritableSignal<string>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hours: string[];
+    /** Minute options at `minuteStep` granularity; an off-step written-in value stays selectable. */
+    protected readonly minutes: _angular_core.Signal<string[]>;
+    private onChange;
+    private onTouched;
+    /** A user pick in the embedded calendar (ngModelChange is view→model only). */
+    protected onDatePicked(): void;
+    protected onHourChange(event: Event): void;
+    protected onMinuteChange(event: Event): void;
+    /** Compose date + time into the ISO value and report it through the CVA. */
+    private commit;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctDatetimePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctDatetimePicker, "strct-datetime-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "monthNames": { "alias": "monthNames"; "required": false; "isSignal": true; }; "weekdayNames": { "alias": "weekdayNames"; "required": false; "isSignal": true; }; "weekdayNamesFull": { "alias": "weekdayNamesFull"; "required": false; "isSignal": true; }; "weekStart": { "alias": "weekStart"; "required": false; "isSignal": true; }; "prevMonthLabel": { "alias": "prevMonthLabel"; "required": false; "isSignal": true; }; "nextMonthLabel": { "alias": "nextMonthLabel"; "required": false; "isSignal": true; }; "hourLabel": { "alias": "hourLabel"; "required": false; "isSignal": true; }; "minuteLabel": { "alias": "minuteLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Action bar for datagrid/card tops — left-aligned projected actions with an
+ * optional selection summary and clear-selection affordance:
+ *
+ *   <strct-toolbar [selectionCount]="sel.size" (cleared)="sel.clear()">
+ *     <button type="button">Restart</button>
+ *     <strct-toolbar-spacer />
+ *     <button type="button">Add VM</button>
+ *   </strct-toolbar>
+ *
+ * `role="toolbar"` with APG keyboard support: ArrowLeft/ArrowRight (Up/Down
+ * when `orientation` is 'vertical', mirrored in RTL) rove focus across the
+ * projected controls, Home/End jump to the first/last. `selectionCount > 0`
+ * prepends a "N selected" chip (label built by the localizable
+ * `selectionLabel` factory) with a × button that emits `(cleared)`.
+ * `strct-toolbar-spacer` pushes following actions to the far end.
+ */
+declare class StrctToolbar {
+    private readonly host;
+    /** Accessible name of the toolbar (localizable). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Roving axis: horizontal bars use Left/Right, vertical use Up/Down. */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** Number of selected rows/items; > 0 shows the selection chip + clear ×. */
+    readonly selectionCount: _angular_core.InputSignal<number>;
+    /** Subtle bottom divider — the classic "actions above the grid" look. */
+    readonly divided: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Builds the selection-chip label from the count (localizable). */
+    readonly selectionLabel: _angular_core.InputSignal<(n: number) => string>;
+    /** Accessible label of the × clear-selection button (localizable). */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /** The × was pressed — clear your selection state. */
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    /** APG toolbar roving across the projected (enabled, tabbable) controls. */
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Tabbable controls inside the bar, in DOM order. */
+    private items;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctToolbar, "strct-toolbar", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "selectionCount": { "alias": "selectionCount"; "required": false; "isSignal": true; }; "divided": { "alias": "divided"; "required": false; "isSignal": true; }; "selectionLabel": { "alias": "selectionLabel"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; }, { "cleared": "cleared"; }, never, ["*"], true, never>;
+}
+/**
+ * Flex spacer for `strct-toolbar` — pushes the actions after it to the far
+ * (inline-end) side of the bar.
+ */
+declare class StrctToolbarSpacer {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctToolbarSpacer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctToolbarSpacer, "strct-toolbar-spacer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Click-to-edit text: display mode shows the value (or a muted localizable
+ * `placeholder` when empty) with a pencil edit affordance that appears on
+ * hover/focus; activating either swaps in an input. Enter commits, Escape
+ * cancels (propagation stopped so an enclosing dialog stays open), blur
+ * commits. The committed value is announced in a live region via
+ * `StrctAnnouncer` (label built by the localizable `announcement` factory).
+ *
+ *   <strct-inline-edit [(ngModel)]="vm.name" />
+ *
+ * A ControlValueAccessor over `string`; `disabled` (attribute) and the forms
+ * API's `setDisabledState` both lock it into display mode.
+ */
+declare class StrctInlineEdit implements ControlValueAccessor {
+    private readonly host;
+    private readonly announcer;
+    /** Static disable; forms' setDisabledState also drives the disabled state. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disabled state pushed by the forms API (setDisabledState). */
+    private readonly cvaDisabled;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Shown (muted) when the value is empty (localizable). */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Accessible label of the pencil edit button and the input (localizable). */
+    readonly editLabel: _angular_core.InputSignal<string>;
+    /** Builds the live-region announcement after a commit (localizable). */
+    readonly announcement: _angular_core.InputSignal<(value: string) => string>;
+    /** Committed value — the CVA model. */
+    readonly value: _angular_core.WritableSignal<string>;
+    /** In-progress text while editing. */
+    protected readonly draft: _angular_core.WritableSignal<string>;
+    protected readonly editing: _angular_core.WritableSignal<boolean>;
+    private onChange;
+    private onTouched;
+    /** Swap display mode for the input; the current value seeds the draft. */
+    protected startEdit(): void;
+    /** Enter commits; Escape cancels (and must not bubble to dialogs/menus). */
+    protected onInputKey(event: KeyboardEvent): void;
+    /** Commit the draft — Enter or blur. No-op once edit mode was left. */
+    protected commit(): void;
+    /** After leaving edit mode, focus lands back on the display value button. */
+    private restoreDisplayFocus;
+    private inputEl;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctInlineEdit, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctInlineEdit, "strct-inline-edit", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "editLabel": { "alias": "editLabel"; "required": false; "isSignal": true; }; "announcement": { "alias": "announcement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Bell button with an unread badge that opens an anchored panel listing the
+ * recent notifications recorded by `StrctToastService` — every shown toast is
+ * kept in a capped history, so the center is the persistent view of what the
+ * toasts announced transiently:
+ *   <strct-notification-center (activated)="open($event)" />
+ *
+ * Clicking an entry marks it read and emits it through `activated` (wire it to
+ * navigation); "mark all read" / "clear all" act on the shared history. Focus
+ * moves into the panel on open, Escape closes with stopPropagation (a host
+ * modal must not close too), and focus returns to the bell on close.
+ */
+declare class StrctNotificationCenter {
+    private readonly host;
+    private readonly service;
+    /** Panel heading and dialog accessible name (localizable). */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Header button that clears the whole history (localizable). */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /** Header button that flags every entry as read (localizable). */
+    readonly markAllReadLabel: _angular_core.InputSignal<string>;
+    /** Shown when the history is empty (localizable). */
+    readonly emptyText: _angular_core.InputSignal<string>;
+    /** Maximum entries rendered in the panel (the newest ones). */
+    readonly maxItems: _angular_core.InputSignal<number>;
+    /**
+     * Factory for the bell's aria-label (localizable); receives the unread
+     * count. When null, a default English label is generated.
+     */
+    readonly bellLabelFormat: _angular_core.InputSignal<((unread: number) => string) | null>;
+    /**
+     * Formatter for an entry's timestamp (localizable). When null, the locale's
+     * short time is shown.
+     */
+    readonly timeFormat: _angular_core.InputSignal<((timestamp: number) => string) | null>;
+    /** Emits the clicked entry (also marked read); the panel closes. */
+    readonly activated: _angular_core.OutputEmitterRef<StrctNotification>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly unread: _angular_core.Signal<number>;
+    protected readonly hasHistory: _angular_core.Signal<boolean>;
+    /** Newest first, capped to `maxItems`. */
+    protected readonly items: _angular_core.Signal<StrctNotification[]>;
+    protected readonly badgeText: _angular_core.Signal<string>;
+    protected readonly bellAria: _angular_core.Signal<string>;
+    private readonly panelEl;
+    /** Element focused before opening — focus returns here on close. */
+    private restoreTo;
+    toggle(): void;
+    close(restore?: boolean): void;
+    /** Pick an entry: mark read, emit, close like a menu selection. */
+    protected activate(n: StrctNotification): void;
+    protected markAllRead(): void;
+    protected clearAll(): void;
+    protected icon(type: StrctToastType): string;
+    protected timeText(n: StrctNotification): string;
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    protected onDocClick(event: MouseEvent): void;
+    /** Fallback for focus landing outside the panel; in-panel Escape stops first. */
+    protected onEscape(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctNotificationCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctNotificationCenter, "strct-notification-center", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "markAllReadLabel": { "alias": "markAllReadLabel"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "maxItems": { "alias": "maxItems"; "required": false; "isSignal": true; }; "bellLabelFormat": { "alias": "bellLabelFormat"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; }, { "activated": "activated"; }, never, never, true, never>;
+}
+
+/** One density value at a row × column intersection. */
+interface StrctHeatmapCell {
+    row: string;
+    col: string;
+    value: number;
+}
+/** Facts handed to `summaryFormat` to build the role="img" aria summary. */
+interface StrctHeatmapSummaryInfo {
+    /** Grid dimensions. */
+    rows: number;
+    cols: number;
+    /** Observed value range (after clamping to the effective `max`). */
+    min: number;
+    max: number;
+}
+interface CellRender {
+    key: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill: string;
+    /** Native tooltip; null for a missing (no-data) cell. */
+    tip: string | null;
+}
+interface LabelRender {
+    text: string;
+    x: number;
+    y: number;
+}
+/**
+ * SVG grid heatmap for density data (host × hour, queue × weekday …).
+ *   <strct-heatmap [data]="cells" [rows]="hosts" [cols]="hours" />
+ *
+ * Each cell's fill is a single-hue intensity ramp — `color-mix` between the
+ * status token and the surface — so the scale stays readable under
+ * color-vision deficiency (luminance, not hue, carries the value). Rows and
+ * columns follow the explicit `rows`/`cols` arrays when given, else first-seen
+ * order in `data`; entries outside an explicit ordering are ignored, and
+ * intersections without data render as empty cells. The SVG is measured (1:1
+ * viewBox) so cells stay crisp at any width; hover a cell for its value.
+ */
+declare class StrctHeatmap {
+    /** Density values; a missing row × col intersection renders as an empty cell. */
+    readonly data: _angular_core.InputSignal<StrctHeatmapCell[]>;
+    /** Explicit row order (top → bottom). Absent: first-seen order in `data`. */
+    readonly rows: _angular_core.InputSignal<string[] | null>;
+    /** Explicit column order (left → right). Absent: first-seen order in `data`. */
+    readonly cols: _angular_core.InputSignal<string[] | null>;
+    /** Scale ceiling — the value that maps to full intensity. Auto (data max) when null. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Base color of the intensity ramp. */
+    readonly status: _angular_core.InputSignal<StrctChartStatus>;
+    /** Shown when there is no data (localizable). */
+    readonly emptyText: _angular_core.InputSignal<string>;
+    /** Accessible name of the chart, leading the role="img" summary (localizable). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Factory for the role="img" aria summary (localizable); receives the
+     * computed facts. When null, a default English summary is generated.
+     */
+    readonly summaryFormat: _angular_core.InputSignal<((info: StrctHeatmapSummaryInfo) => string) | null>;
+    /** Cell height in pixels (widths flex to the measured container). */
+    readonly cellHeight: _angular_core.InputSignal<number>;
+    /** Gap between cells in pixels. */
+    readonly gap: _angular_core.InputSignal<number>;
+    /** Left gutter width for the row labels in pixels. */
+    readonly rowLabelWidth: _angular_core.InputSignal<number>;
+    /** Measured pixel width → 1:1 viewBox so cells stay crisp at any size. */
+    protected readonly width: _angular_core.WritableSignal<number>;
+    private readonly host;
+    constructor();
+    protected readonly rowOrder: _angular_core.Signal<string[]>;
+    protected readonly colOrder: _angular_core.Signal<string[]>;
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    /** Last write wins when a row × col pair appears twice. */
+    private readonly valueMap;
+    /** Effective scale ceiling: explicit `max`, else the data's own maximum. */
+    protected readonly maxVal: _angular_core.Signal<number>;
+    private readonly color;
+    /** Cell width: the plot flexes to the measured container width. */
+    private readonly cellW;
+    protected readonly height: _angular_core.Signal<number>;
+    protected readonly cells: _angular_core.Signal<CellRender[]>;
+    protected readonly rowLabels: _angular_core.Signal<LabelRender[]>;
+    protected readonly colLabels: _angular_core.Signal<LabelRender[]>;
+    /** Screen-reader summary of the whole grid (role="img" name). */
+    protected readonly aria: _angular_core.Signal<string>;
+    /**
+     * Intensity ramp: 8% of the status hue for the smallest non-zero value up
+     * to 100% at the ceiling; zero stays on the empty-cell surface.
+     */
+    private fillFor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StrctHeatmap, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StrctHeatmap, "strct-heatmap", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "summaryFormat": { "alias": "summaryFormat"; "required": false; "isSignal": true; }; "cellHeight": { "alias": "cellHeight"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "rowLabelWidth": { "alias": "rowLabelWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FOCUSABLE_SELECTOR, STRCT_DP_DOW, STRCT_DP_DOW_FULL, STRCT_DP_MONTHS, STRCT_ICONS, STRCT_ICON_GROUPS, STRCT_ICON_NAMES, STRCT_MASKS, STRCT_NOTIFICATION_HISTORY_LIMIT, STRCT_PALETTES, STRCT_RAW_ICONS, STRCT_TIME_RANGE_PRESETS, STRCT_WIZARD_DEFAULTS, StrctAccordion, StrctAccordionPanel, StrctAlert, StrctAnnouncer, StrctAvatar, StrctBadge, StrctBreadcrumb, StrctBreadcrumbItem, StrctButton, StrctButtonGroup, StrctBytesPipe, StrctCard, StrctCardBlock, StrctCardFooter, StrctCardHeader, StrctCascadeColumn, StrctCascadeHost, StrctCascadeSelect, StrctCellDef, StrctCellStatus, StrctChart, StrctCheckbox, StrctChips, StrctCode, StrctColorPicker, StrctCombobox, StrctCommandPalette, StrctConfirmOutlet, StrctConfirmService, StrctContextMenu, StrctContextMenuTrigger, StrctCopy, StrctDatagrid, StrctDatagridActionBar, StrctDatepicker, StrctDatetimePicker, StrctDesc, StrctDescriptionList, StrctDiff, StrctDivider, StrctDonut, StrctDrawer, StrctDrawerFooter, StrctDropdown, StrctDropdownDivider, StrctDropdownItem, StrctDropdownTrigger, StrctDurationPipe, StrctEmptyState, StrctField, StrctFile, StrctFilterBar, StrctFlow, StrctFooter, StrctGauge, StrctHeader, StrctHeatmap, StrctHero, StrctHotkeysHelp, StrctHotkeysService, StrctIcon, StrctInlineEdit, StrctInput, StrctInputMask, StrctInputOtp, StrctKbd, StrctKnob, StrctLogViewer, StrctLogin, StrctMenuPanel, StrctMenuService, StrctMenubar, StrctMetricTile, StrctModal, StrctNav, StrctNavItem, StrctNotificationCenter, StrctNumber, StrctOverlay, StrctPageHeader, StrctPageHeaderActions, StrctPageHeaderCrumbs, StrctPagination, StrctPassword, StrctPopover, StrctPopoverTrigger, StrctProgress, StrctRadio, StrctRadioGroup, StrctRail, StrctRange, StrctRatePipe, StrctRating, StrctReorder, StrctReorderItem, StrctRowDetailDef, StrctSearchbox, StrctSectionMenu, StrctSegmented, StrctSelect, StrctShell, StrctShellService, StrctSiPipe, StrctSignpost, StrctSignpostTrigger, StrctSkeleton, StrctSparkline, StrctSpeedDial, StrctSpinner, StrctSplitButton, StrctSplitter, StrctStack, StrctStackItem, StrctStatusDot, StrctStep, StrctSubmenu, StrctTab, StrctTable, StrctTabs, StrctTag, StrctThemeService, StrctThemeSwitcher, StrctTimeRangePicker, StrctTimeline, StrctTimelineItem, StrctToastOutlet, StrctToastService, StrctToggle, StrctToolbar, StrctToolbarSpacer, StrctTooltip, StrctTour, StrctTransfer, StrctTree, StrctTreeNode, StrctTreeSelect, StrctVerticalNav, StrctWatermark, StrctWizard, StrctWizardAside, focusFirstIn, keepTabInside, lockBodyScroll, parseAnsi, provideStrctWizardDefaults, registerStrctIcon, restoreFocus, saveFocusedElement, strctComputeDiff, strctDpPad, strctFormatBytes, strctFormatDuration, strctFormatRate, strctFormatSi, strctValidationIcon, strctValidationTone, unlockBodyScroll };
+export type { StrctAlertType, StrctAvatarSize, StrctAvatarStatus, StrctBadgeStatus, StrctButtonSize, StrctButtonVariant, StrctCascadeOption, StrctCellContext, StrctChartAnnotation, StrctChartColor, StrctChartCurve, StrctChartSeries, StrctChartSlot, StrctChartStatus, StrctChartSummaryInfo, StrctChartThreshold, StrctChartType, StrctColumn, StrctCommandItem, StrctConfirmOptions, StrctConfirmTone, StrctDatagridColumn, StrctDatagridColumnState, StrctDatagridFilters, StrctDatagridLabels, StrctDatagridLazyState, StrctDescAlign, StrctDescItem, StrctDiffRow, StrctDonutSegment, StrctDrawerSide, StrctDrawerSize, StrctEmptyVariant, StrctFilterChip, StrctFlowDirection, StrctFlowNode, StrctFlowOrientation, StrctHeatmapCell, StrctHeatmapSummaryInfo, StrctHotkey, StrctIconBadge, StrctIconName, StrctKnobStatus, StrctLogLine, StrctMenuItem, StrctMenuLink, StrctMenuOpenOptions, StrctMenuSection, StrctMenubarItem, StrctMetricStatus, StrctModalSize, StrctMode, StrctNotification, StrctOption, StrctOverlayPlacement, StrctPalette, StrctPaletteInfo, StrctProgressStatus, StrctRailItem, StrctRailStatus, StrctReorderEvent, StrctRow, StrctRowId, StrctSegmentedOption, StrctSegmentedSize, StrctSignpostPosition, StrctSpeedDialDirection, StrctSpinnerSize, StrctStatus, StrctStatusDotSize, StrctTagStatus, StrctThresholds, StrctTimeRange, StrctTimeRangePreset, StrctTimelineState, StrctToast, StrctToastOptions, StrctToastType, StrctTooltipPosition, StrctTourStep, StrctTransferItem, StrctTreeMenuEvent, StrctTreeNodeData, StrctTreeNodeMenuFn, StrctValidationState, StrctValidationStatus, StrctWizardDefaults };