@flyos/design-system 1.7.0 → 1.8.0

package/types/flyos-design-system.d.ts

@@ -1779,8 +1779,11 @@ declare class I18nService {
  * is a safe default that an integrator can override without coordination.
  *
  * Scope: only the keys the **shippable** DS components reference today
- * (`common.*` toolbar/link/emoji-picker labels + `agent.lookup.*` + `select.*` + `typeahead.*` + `cron.*` + `gantt.*` + `form.*` + `captcha.*` + `comment.*` + `canvas_board.*` + `moderation.*` + `people_picker.*` + `pagination.*` + `tree_nav.*`). When a new DS component
- * starts using `| translate`, add its keys here so it stays self-sufficient.
+ * (`common.*` toolbar/link/emoji-picker labels + `agent.lookup.*` + `select.*` + `typeahead.*` + `cron.*` + `gantt.*` + `form.*` + `captcha.*` + `comment.*` + `canvas_board.*` + `moderation.*` + `people_picker.*` + `currency_selector.*` + `pagination.*` + `tree_nav.*` + `magic_actions.*`). When a new DS component
+ * starts using `| translate` **or `I18nService.t()`**, add its keys here so it stays
+ * self-sufficient — `fly-magic-actions` shipped resolving three keys that existed only in the
+ * shell bundle, so an External App rendering it got the raw key string as every disabled
+ * tooltip and every radio-menu trigger's accessible name (S1-review F5).
  * Values are copied verbatim from the shell's `public/locale/*.json` — keep
  * them in sync if either side changes.
  */
@@ -4407,6 +4410,18 @@ interface ContextMenuItem {
      * further children, each rendered as another nested `fly-context-menu` instance.
      */
     children?: ContextMenuItem[];
+    /**
+     * Set on EVERY item of a mutually-exclusive group (e.g. a Status/Sort radio menu) to opt
+     * that whole group into radio semantics: `undefined` (default, omitted) renders the plain
+     * `role="menuitem"` row this component always has; a `boolean` here renders
+     * `role="menuitemradio"` with `aria-checked` and the selected row's 600-weight + accent-
+     * check treatment (skill §6 "selected --w08 + 600 + accent check"). Additive — a caller
+     * that never sets this sees no change. The row's own `icon` is untouched and keeps
+     * rendering as today; the accent check this adds is a SEPARATE trailing indicator, so a
+     * caller mid-migration (still passing `icon: 'pi-check'` on the selected row) does not get
+     * a doubled glyph in the leading position — only a second, dedicated one at the row's end.
+     */
+    selected?: boolean;
 }
 interface ContextMenuSection {
     label?: string;
@@ -4470,7 +4485,7 @@ declare class ContextMenuComponent implements AfterViewInit, OnDestroy {
     align: _angular_core.InputSignal<ContextMenuAlign>;
     /** See {@link ContextMenuPlacement}. Ignored without an `[anchor]`. */
     placement: _angular_core.InputSignal<ContextMenuPlacement>;
-    sections: _angular_core.InputSignal<ContextMenuSection[]>;
+    sections: _angular_core.InputSignal<readonly ContextMenuSection[]>;
     /**
      * Optional containing rect (viewport coords, e.g. from
      * `el.getBoundingClientRect()`) to keep the menu inside — for menus opened
@@ -5072,6 +5087,16 @@ type FlyDrawerSize = 'sm' | 'md' | 'lg' | 'xl';
 type FlyDrawerSide = 'end' | 'start';
 /** Standard body padding tier. `none` = full-bleed (consumer draws its own). */
 type FlyDrawerBodyPadding = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * `'side'` (default) — the classic edge-pinned panel, sliding in along the inline axis
+ * (see {@link FlyDrawerSide}). `'sheet'` — a bottom-anchored panel spanning the full
+ * inline size, sliding up from the block-end edge with rounded top corners; `side` is
+ * ignored in this mode (there is no edge to pick — a sheet always anchors to the
+ * bottom). Stage 5 of the UX-refresh program converts every `side` drawer to a `sheet`
+ * on mobile; this variant is the primitive that makes that conversion a per-consumer
+ * `variant` flip rather than a second component.
+ */
+type FlyDrawerVariant = 'side' | 'sheet';
 /**
  * Where the drawer is anchored.
  * - `absolute` (default) — clipped to the nearest positioned ancestor, i.e. the
@@ -5123,8 +5148,10 @@ declare class FlyDrawerComponent {
     readonly size: _angular_core.InputSignal<FlyDrawerSize>;
     /** Convenience title shown in the default header (ignored if `[flyDrawerHeader]` is projected). Treated as an i18n key. */
     readonly heading: _angular_core.InputSignal<string | null>;
-    /** Edge to pin to. `end` (default) slides from inline-end; RTL flips it. */
+    /** Edge to pin to. `end` (default) slides from inline-end; RTL flips it. Ignored when `variant` is `sheet`. */
     readonly side: _angular_core.InputSignal<FlyDrawerSide>;
+    /** `side` (default, edge-pinned) or `sheet` (bottom-anchored, full-width). See {@link FlyDrawerVariant}. */
+    readonly variant: _angular_core.InputSignal<FlyDrawerVariant>;
     /** Close when the scrim is clicked. */
     readonly dismissOnScrim: _angular_core.InputSignal<boolean>;
     /** Close on Escape. */
@@ -5158,9 +5185,10 @@ declare class FlyDrawerComponent {
      *  which can race the leaving toggle and stutter the animation). */
     readonly panelClass: _angular_core.Signal<{
         [x: string]: boolean;
+        'fly-drawer__panel--sheet': boolean;
     }>;
-    /** Name of the exit keyframe — used to ignore bubbled child animationend events. */
-    private static readonly EXIT_ANIM;
+    /** Exit keyframe names — one per variant — used to ignore bubbled child animationend events. */
+    private static readonly EXIT_ANIMS;
     /** Element focused before the drawer opened, restored on close. */
     private previouslyFocused;
     /** Parent element whose overflow we lock while open. */
@@ -5181,7 +5209,7 @@ declare class FlyDrawerComponent {
     private releaseScrollLock;
     private restoreFocus;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyDrawerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyDrawerComponent, "fly-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "dismissOnScrim": { "alias": "dismissOnScrim"; "required": false; "isSignal": true; }; "dismissOnEscape": { "alias": "dismissOnEscape"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "hideCloseButton": { "alias": "hideCloseButton"; "required": false; "isSignal": true; }; "bodyPadding": { "alias": "bodyPadding"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "openChange": "openChange"; }, never, ["[flyDrawerHeader]", "*", "[flyDrawerFooter]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyDrawerComponent, "fly-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissOnScrim": { "alias": "dismissOnScrim"; "required": false; "isSignal": true; }; "dismissOnEscape": { "alias": "dismissOnEscape"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "hideCloseButton": { "alias": "hideCloseButton"; "required": false; "isSignal": true; }; "bodyPadding": { "alias": "bodyPadding"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "openChange": "openChange"; }, never, ["[flyDrawerHeader]", "*", "[flyDrawerFooter]"], true, never>;
 }
 
 /**
@@ -5363,6 +5391,16 @@ interface FlySelectRenderGroup {
     key: string | null;
     options: FlySelectOption[];
 }
+/** Resolved fixed-position geometry for the portaled panel. */
+interface FlySelectPanelPosition {
+    readonly top: number | null;
+    readonly bottom: number | null;
+    readonly left: number | null;
+    readonly right: number | null;
+    readonly minWidth: number;
+    readonly maxHeight: number;
+    readonly flipAbove: boolean;
+}
 /**
  * **`fly-select`** — the design-system searchable select / combobox.
  *
@@ -5378,12 +5416,29 @@ interface FlySelectRenderGroup {
  * each input defaults to the `select.*` key in `DS_BASELINE_LOCALES` (en/ar/fr/ur), and passing the
  * input still wins. It used to default to a hardcoded English literal that every consumer had to
  * remember to override — none did, so a searchable select read "Search…" under ar/fr/ur.
- * Styling uses DS theme tokens (`--surface-card`,
- * `--surface-border`, `--text-color`, `--primary-color`, …) with light-neutral fallbacks so it stays
- * readable in consumers that haven't mapped the tokens.
- *
- * Pattern mirrors {@link EntityLookupComponent}: an absolutely-positioned panel (no CDK Overlay),
- * signal-driven `activeIndex` keyboard nav, and a `document:mousedown` click-outside guard.
+ * Styling composes the Nova token language (`--w*` ramp, `--accent`, `nova-glass.popover`) — see
+ * `skills/desktop-design-language.md` §3.2 and `.workflow/plans/ux-refresh/notes/S1.7-form-family.md`.
+ *
+ * **Positioning (S1.7 — Nova):** the panel is `position: fixed`, measured from the trigger, and
+ * **portaled to `<body>`** the same way {@link ContextMenuComponent} escapes a clipping/glass
+ * ancestor — see that file's `ngAfterViewInit` for the precedent. Two DS-1.x findings this fixes:
+ * the panel used to be `position: absolute` against a `position: relative` host, which is immune to
+ * the transformed-ancestor trap but vulnerable to an `overflow: hidden` ancestor (a drawer body, an
+ * app-window panel) clipping it; and `nova-glass.popover` puts `backdrop-filter` on the listbox,
+ * and a `backdrop-filter` ancestor (e.g. a glass drawer) turns into a *backdrop root* — a nested
+ * `backdrop-filter` then samples the ancestor's own painted content instead of the wallpaper and
+ * reads as flat mud. Body-parenting resolves BOTH at once: once the panel is a direct child of
+ * `<body>` it is no longer a descendant of any clipping or glass ancestor, so it escapes the clip
+ * *and* is never "nested" glass — no `$nested: true` needed, the full translucent recipe renders
+ * correctly every time. The panel flips above the trigger when fewer than 180px of room remains
+ * below it, clamps its `max-height` into 120–242px, and closes (not repositions — D2 §3.2) on any
+ * outside pointerdown (capture phase, so it isn't defeated by an inner `stopPropagation`), any
+ * ancestor scroll (capture phase — scroll doesn't bubble, and a select routinely sits inside a
+ * scrolling drawer body), or a window resize. Mirrors {@link FlyTooltipDirective}'s scroll/resize
+ * dismiss idiom.
+ *
+ * Pattern mirrors {@link EntityLookupComponent}: no CDK Overlay, signal-driven `activeIndex`
+ * keyboard nav.
  */
 declare class FlySelectComponent implements ControlValueAccessor {
     private readonly host;
@@ -5434,9 +5489,37 @@ declare class FlySelectComponent implements ControlValueAccessor {
     private _touched;
     private readonly searchEl?;
     private readonly triggerEl?;
+    /** Signal query (not a decorator): the panel is created/destroyed by the template's `@if`, and the
+     *  portal effect below needs to react every time a NEW instance mounts, not just once at init. */
+    private readonly panelEl;
+    private readonly document;
+    private readonly destroyRef;
+    /** Trigger geometry sampled at open time (and cleared on close) — the only input the fixed
+     *  position math needs. Re-sampled on open, never on scroll/resize: those close the panel
+     *  instead of repositioning it (D2 §3.2), so there is nothing to keep in sync while it's up. */
+    private readonly _triggerRect;
+    private readonly _triggerRtl;
     private _onChange;
     private _onTouched;
+    private readonly _onOutsidePointerDown;
+    private readonly _onOutsideScroll;
+    private readonly _onWindowResize;
+    constructor();
+    /** Registered only while open (mirrors {@link FlyTooltipDirective}'s show/hide discipline) —
+     *  a page can carry many selects, and there is no reason for a closed one to keep three
+     *  window-level listeners live. */
+    private _attachDismissListeners;
+    private _detachDismissListeners;
     readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Fixed-position geometry for the panel, computed purely from the trigger rect sampled at open
+     * time — no post-render measurement pass. Flips above the trigger under 180px of room below (and
+     * only when there's MORE room above), clamps `max-height` into 120–242px, and anchors the panel's
+     * reading-start edge to the trigger's reading-start edge (RTL-aware), growing toward reading-end —
+     * the same anchor behaviour the CSS `inset-inline: 0 auto` gave it before it needed a physical
+     * `position: fixed` value to escape its ancestor.
+     */
+    readonly panelPosition: _angular_core.Signal<FlySelectPanelPosition | null>;
     readonly placeholderText: _angular_core.Signal<string>;
     readonly searchPlaceholderText: _angular_core.Signal<string>;
     readonly noResultsText: _angular_core.Signal<string>;
@@ -5469,6 +5552,8 @@ declare class FlySelectComponent implements ControlValueAccessor {
     toggleOpen(): void;
     open(): void;
     close(refocusTrigger?: boolean): void;
+    /** Sampled once per open — see the `_triggerRect` field doc for why this never re-samples while open. */
+    private _sampleTriggerRect;
     onTriggerKeydown(ev: KeyboardEvent): void;
     onPanelKeydown(ev: KeyboardEvent): void;
     private _selectActive;
@@ -5480,7 +5565,6 @@ declare class FlySelectComponent implements ControlValueAccessor {
     /** Clear the whole selection from the trigger ✕. Stops propagation so it never opens the panel. */
     clear(ev?: Event): void;
     onSearchInput(value: string): void;
-    onDocumentMouseDown(ev: MouseEvent): void;
     private _normalizedValue;
     private _emit;
     private _markTouched;
@@ -7136,6 +7220,1031 @@ declare class AgentFlightAnimator {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<AgentFlightAnimator>;
 }
 
+/**
+ * Magic-bar contribution contract (UX v2 "Nova", D5 §4).
+ *
+ * The magic bar is the shell's top-bar toolbar pill. Unlike the fixed right
+ * cluster (Help / Tasks / Notifications / assistant orb — shell-owned, an app can
+ * never remove it), the pill's contents belong to **whatever view the user is
+ * looking at**, and the design's reference implementation re-publishes the whole
+ * set on every selection, tab and save (`pubTabActions`). Two consequences shape
+ * every type below:
+ *
+ *  1. **A contribution is a full replace, never a patch.** There is no "add one
+ *     action" call, because the publisher never knows what the previous view left
+ *     behind. That also collapses D5's `search: null` ("suppress") vs `search`
+ *     absent distinction — under full replace both simply mean "this view offers
+ *     no search".
+ *  2. **Render data and behaviour are separated in the type system.** Each family
+ *     has a `*Spec` base carrying ONLY the fields that affect what is painted;
+ *     the publisher-facing type extends it with callbacks, and the shell-facing
+ *     `*View` type extends it with bound invokers. The base IS the equality
+ *     surface {@link MagicBarRegistry} dedupes on — a re-publish whose specs are
+ *     unchanged must not disturb the shell, even though its closures are brand
+ *     new objects every time (an arrow function in a component method never
+ *     compares equal to its predecessor). See `magic-bar-projection.ts`.
+ *
+ * **Strings are i18n keys, never resolved text** — same rule as
+ * {@link AgentCommandRegistration} (`labelKey` / `descriptionKey` / `hintKey`),
+ * for the same two reasons: a contribution outlives a locale switch (a resolved
+ * label would silently go stale until the publisher happened to re-publish), and
+ * keys are locale-invariant so the dedupe fingerprint doesn't churn when the user
+ * changes language. Keys resolve in the OWNING app's bundle.
+ *
+ * **Every `*Key` has an optional `*Params` sibling** ({@link MagicBarTextParams}),
+ * fed straight to `I18nService.t(key, params)`. Without it a count-carrying string
+ * ("Search 1,204 tasks…") forces the publisher to pass pre-formatted TEXT as the
+ * key: it renders correctly in `en`, renders identically untranslated in ar/fr/ur,
+ * and no locale tool can see it. Params participate in the dedupe fingerprint, so
+ * a changing count re-paints.
+ *
+ * Which of D5 §4's "dynamics the shell must honor" live where:
+ *
+ * | # | Dynamic | Owner |
+ * |---|---|---|
+ * | 1 | Live re-publication, idempotent replace | {@link MagicBarRegistry} (here) |
+ * | 2 | Disabled ≠ hidden, auto disabled-tooltip | contract keeps `disabled` rows; `fly-magic-actions` renders + suffixes |
+ * | 3 | `toolbarPopIn` 40 ms stagger | renderer — it tracks on {@link MagicBarActionSpec.id}, which is why ids are unique across the WHOLE contribution |
+ * | 4 | i18n on every label/tip | contract (keys + params, above) |
+ * | 5 | Fixed right cluster is not contributable | contract — no slot exists for it |
+ * | 6 | Mobile renders the same contribution | contract carries no form-factor branch; `openWidth` is a desktop hint mobile ignores |
+ * | 7 | `shortcut` reserved (design has no shortcut affordance yet) | contract — carried, unrendered |
+ *
+ * On dynamic 3 specifically: the registry's dedupe does NOT stop the stagger
+ * replaying, and believing it does would produce a renderer that re-animates on
+ * every click. Dedupe fires only when *nothing painted* changed, and the dominant
+ * case — `disabled: !hasSelection` — changes the fingerprint on every selection.
+ * What holds the DOM still is the renderer's `@for (…; track item.id)`.
+ */
+/** How an action paints. `'text'` is the labelled-pill form (calendar's "Today"). */
+type MagicBarActionKind = 'icon' | 'text' | 'toggle';
+/**
+ * Semantic colour of an action. `'danger'` is the red Delete treatment (red glyph
+ * + red 18 % hover tint, D7); `'success'` is the green "Mark as complete" pressed
+ * state (D5 §1.4 + §4 prop table: "pressed bg tint-sel / green for complete").
+ *
+ * A union rather than the boolean `danger` this started as: the design already
+ * demands a second colour, and widening a shipped `danger?: boolean` into a union
+ * later would mean REMOVING an interface member — MAJOR under `tools/ds-compat`
+ * (rule 7), which forks the federation singleton for every remote.
+ */
+type MagicBarTone = 'default' | 'danger' | 'success';
+/**
+ * Interpolation params for one i18n key — the `params` argument of
+ * `I18nService.t(key, params)`, substituting `{{name}}` placeholders.
+ *
+ * Values are `string | number` only: the fingerprint has to encode them, and the
+ * renderer resolves them through `t()`, which stringifies. A `Date` or a nested
+ * object would fingerprint as `{}` and paint as `[object Object]`.
+ */
+type MagicBarTextParams = Readonly<Record<string, string | number>>;
+/**
+ * Identity of a contribution's publisher, and the arbitration key the shell uses
+ * to pick which contribution the bar renders.
+ *
+ * `windowId` is optional but strongly preferred: two windows of the same app can
+ * be open on different selections, and keying on `appId` alone would let the
+ * background one paint the focused one's toolbar. It is optional only because a
+ * federated remote that predates per-window plumbing can still contribute —
+ * {@link MagicBarRegistry} resolves an `appId`-keyed slot as a fallback.
+ *
+ * It only has to be unique **within the publishing app** (the shell passes its own
+ * `win-<appId>-<timestamp>` window id; a tab index or a route-derived id is equally
+ * valid) — {@link magicBarOwnerKey} scopes it by `appId`, so a value another app
+ * also uses can never cross over.
+ */
+interface MagicBarOwnerRef {
+    readonly appId: string;
+    readonly windowId?: string;
+}
+/**
+ * Storage/arbitration key for an owner. Exported because the shell computes it
+ * on the janitor path (`clear` after a window closes) without holding the
+ * publisher.
+ *
+ * **Both fields key the slot**, even though the shell's own ids
+ * (`win-<appId>-<timestamp>`) are already unique. `windowId` is publisher-supplied
+ * DATA that crosses the federation boundary, and the field is documented only as
+ * "two windows of the same app" — nothing stops a remote passing a tab index or a
+ * route-derived id. Keyed on `windowId` alone, two apps that both call their first
+ * window `"1"` would share a slot: one silently paints the other's chrome, and the
+ * shell's janitor `clear()` wipes the wrong one.
+ */
+declare function magicBarOwnerKey(owner: MagicBarOwnerRef): string;
+/** One `menuitemradio` row. `value` is the publisher's own vocabulary. */
+interface MagicBarRadioOption {
+    readonly value: string;
+    readonly labelKey: string;
+    /** Params for {@link labelKey} — the count-badged option ("All statuses ({{count}})"). */
+    readonly labelParams?: MagicBarTextParams;
+}
+/** Render surface of a radio menu — the dedupe key for {@link MagicBarRadioMenu}. */
+interface MagicBarRadioMenuSpec {
+    /** Eyebrow above the options ("Filter by status" / "Sort by"). */
+    readonly titleKey: string;
+    /** Params for {@link titleKey}. */
+    readonly titleParams?: MagicBarTextParams;
+    readonly options: readonly MagicBarRadioOption[];
+    /** Current selection — check glyph + 600 weight on the matching row. */
+    readonly value: string;
+    /** The unfiltered/unsorted baseline; the trigger shows its accent dot iff `value !== defaultValue`. */
+    readonly defaultValue: string;
+}
+/** What a publisher supplies for a radio menu. */
+interface MagicBarRadioMenu extends MagicBarRadioMenuSpec {
+    readonly onSelect?: (value: string) => void;
+}
+/** What the shell renders. `select` always exists; it no-ops when the publisher supplied no handler. */
+interface MagicBarRadioMenuView extends MagicBarRadioMenuSpec {
+    select(value: string): void;
+}
+/**
+ * Render surface of an action — the dedupe key for {@link MagicBarAction}.
+ *
+ * `id` must be unique across the WHOLE contribution (every group, plus `primary`
+ * and `overflow`), not merely within its group: it is the address the shell's
+ * invoker resolves against the publisher's latest handlers.
+ */
+interface MagicBarActionSpec {
+    readonly id: string;
+    /** i18n key — the `aria-label` and the default tooltip. */
+    readonly labelKey: string;
+    /** Params for {@link labelKey}, e.g. `{ count: 3 }` for "Delete {{count}} items". */
+    readonly labelParams?: MagicBarTextParams;
+    /**
+     * Inner-SVG geometry for a 24×24 glyph (`stroke-width: 1.8`, round caps) —
+     * the design's icon transport. Reference {@link FLY_MAGIC_BAR_ICONS} by name
+     * rather than hand-authoring; a publisher MAY author its own, subject to the
+     * contract below.
+     *
+     * **This value is not trusted.** The renderer parses it against a closed
+     * allowlist — self-closing `path`/`circle`/`rect`/`ellipse`/`line`/`polyline`/
+     * `polygon` elements carrying geometry attributes only (`d`, `cx`, `points`,
+     * …) — and binds the result as real attributes. It is never assigned as HTML.
+     * Anything else (a container element, an `on*` handler, `style`, `href`,
+     * `fill="url(…)"`, a stray text node) rejects the WHOLE fragment: the button
+     * renders with no glyph and logs. See `magic-actions-icon.ts`.
+     *
+     * The type stays `string` deliberately. Narrowing it to a branded/opaque type
+     * would be a ds-compat MAJOR, and it would not buy anything the renderer's own
+     * validation does not already guarantee — a nominal type describes where a
+     * value came from, not what it contains.
+     */
+    readonly iconPath?: string;
+    /** Default `'icon'`. */
+    readonly kind?: MagicBarActionKind;
+    /** Dimmed (`opacity .38`), NEVER hidden — a vanishing action teaches the user nothing. */
+    readonly disabled?: boolean;
+    /**
+     * Tooltip override while disabled. Absent is the normal case: the renderer
+     * auto-suffixes the resolved label ("… — select an item first"). Resolution
+     * and the connector phrasing are the renderer's job precisely because they are
+     * locale work, and this store holds keys rather than text.
+     */
+    readonly disabledTipKey?: string;
+    /** Params for {@link disabledTipKey}. */
+    readonly disabledTipParams?: MagicBarTextParams;
+    /** Tooltip override while enabled. Absent → the renderer uses `labelKey`. */
+    readonly tipKey?: string;
+    /** Params for {@link tipKey}. */
+    readonly tipParams?: MagicBarTextParams;
+    /**
+     * Semantic colour. Default `'default'`; `'danger'` is the ONLY thing that makes
+     * an icon red (D7), `'success'` the green completed-toggle treatment.
+     */
+    readonly tone?: MagicBarTone;
+    /** `aria-pressed` for `kind: 'toggle'`. */
+    readonly pressed?: boolean;
+    /** Small accent dot — a non-default filter/sort is active. */
+    readonly badgeDot?: boolean;
+    /**
+     * Reserved (D5 §4 item 7). The designs carry no keyboard-shortcut affordance
+     * anywhere; the field exists so adding one later is a renderer change rather
+     * than a contract break. Nothing renders it today.
+     */
+    readonly shortcut?: string;
+}
+/** What a publisher supplies for one action. */
+interface MagicBarAction extends MagicBarActionSpec {
+    readonly menu?: MagicBarRadioMenu;
+    readonly onSelect?: () => void;
+}
+/**
+ * What the shell renders. `run()` always exists and always dispatches to the
+ * publisher's LATEST handler for this id — including after a re-publish the
+ * registry deliberately did not propagate (see `magic-bar-projection.ts`).
+ */
+interface MagicBarActionView extends MagicBarActionSpec {
+    readonly menu: MagicBarRadioMenuView | null;
+    run(): void;
+}
+/** Render surface of a group — the dedupe key for {@link MagicBarGroup}. */
+interface MagicBarGroupSpec {
+    readonly id: string;
+    /** i18n key for the `role="group"` aria-label ("Signal actions"). */
+    readonly labelKey: string;
+    /** Framed variant: 2 px gaps + a trailing separator. Plain (default) uses 8 px gaps. */
+    readonly framed?: boolean;
+}
+interface MagicBarGroup extends MagicBarGroupSpec {
+    readonly items: readonly MagicBarAction[];
+}
+interface MagicBarGroupView extends MagicBarGroupSpec {
+    readonly items: readonly MagicBarActionView[];
+}
+/**
+ * Render surface of the expanding search field — the dedupe key for
+ * {@link MagicBarSearch}.
+ *
+ * This is a per-page typeahead, NOT a command palette: neither design package
+ * has a global ⌘K surface, and the only "command" affordance is the Ask-AI menu.
+ */
+interface MagicBarSearchSpec {
+    /** Context-aware placeholder key ("Search tasks…", "Search events…"). */
+    readonly placeholderKey: string;
+    /** Params for {@link placeholderKey}, e.g. `{ count: 1204 }` for "Search {{count}} tasks…". */
+    readonly placeholderParams?: MagicBarTextParams;
+    /**
+     * The text the search field should SHOW — literal text, not an i18n key, because
+     * it is the user's own query rather than a caption.
+     *
+     * Exists because a view can arrive **already filtered**: a deep link carrying
+     * `?q=…`, a restored session, a filter applied from a detail pane. Without it the
+     * box renders empty over a visibly filtered list, and the user is looking at a
+     * contradiction the chrome cannot explain.
+     *
+     * ## Why it is not called `query`
+     * {@link MagicBarSearchView} — which extends this interface — already declares
+     * `query(text: string): void`, the late-bound invoker. A `query?: string` here
+     * would make that view an illegal extension (TS2430: `(text: string) => void` is
+     * not assignable to `string | undefined`), and the only other way out — renaming
+     * the invoker — removes a member of a shipped exported interface, which is a
+     * ds-compat MAJOR (rule 7) and forks the federation singleton for every remote.
+     * So the field takes the name that pairs with the invoker instead of colliding
+     * with it: `queryText` is the text, `query()` submits it.
+     *
+     * ## Precedence — this is a SEED, not a controlled value
+     * The field's live text is owned by the **shell**, because the user types into
+     * it. This field is the publisher's chance to move it, and the shell adopts the
+     * published value exactly three times:
+     *
+     *  1. the first time it binds this view,
+     *  2. when {@link MagicBarContribution.viewKey} changes (reset-on-navigate — the
+     *     previous view's query must not survive into the next one), and
+     *  3. when the published value **itself changes** from the one previously
+     *     published.
+     *
+     * A re-publish carrying an UNCHANGED `queryText` never touches what the user has
+     * typed. That third clause is the whole rule: the dominant re-publish is
+     * `disabled: !hasSelection` flipping on a selection change, and a shell that
+     * re-read `queryText` on every emitted view would revert a keystroke every time
+     * the user selected a row mid-search — the classic controlled-input bug. The rule
+     * is authored once, as {@link magicBarSearchText}, so no renderer re-derives it.
+     *
+     * `undefined` and `''` are **different** and the difference is load-bearing:
+     * absent means "this view does not manage the field" (nothing is ever forced),
+     * `''` means "clear it". Both the fingerprint and the seed comparison distinguish
+     * them.
+     *
+     * ## Do not echo the user's keystrokes back through this field
+     * A publisher that mirrors its `onQuery` argument straight back into `queryText`
+     * is harmless (the seed changes to text the field already shows). A publisher
+     * that mirrors it back **debounced** is not: typing "abc" then publishing
+     * `queryText: 'a'` 300 ms later is, by rule 3, a genuine publisher-initiated
+     * change, and the field snaps back to "a". Publish here only for state the view
+     * owns independently of the field.
+     */
+    readonly queryText?: string;
+    /**
+     * Expanded width in px — a **desktop layout hint**, carried verbatim.
+     *
+     * The design's range is 140–420 (default 230), but this store deliberately does
+     * NOT validate or clamp it: enforcing a paint range here would reject a whole
+     * contribution over a cosmetic hint (leaving the previous view's actions in the
+     * chrome), and mobile ignores the field entirely, so there is no single range to
+     * enforce. `fly-magic-actions` clamps to the design range at paint time and is
+     * the only place that decides what an out-of-range or non-finite value means.
+     */
+    readonly openWidth?: number;
+    /** Accent dot on the Filters button — a non-default filter is applied. */
+    readonly filtersActive?: boolean;
+}
+interface MagicBarSearch extends MagicBarSearchSpec {
+    readonly onQuery?: (query: string) => void;
+    /**
+     * Opens the view's own Advanced-search overlay. Presence of this handler is
+     * what makes the Filters button exist — the DS deliberately does not model the
+     * dialog itself. Its fields are app schema (Circles' PESTLE/horizon grid), and
+     * a descriptor for them would be business logic the design system cannot
+     * validate or render honestly.
+     */
+    readonly onOpenFilters?: () => void;
+}
+interface MagicBarSearchView extends MagicBarSearchSpec {
+    /** True iff the publisher can open an advanced-search overlay. */
+    readonly hasFilters: boolean;
+    /**
+     * Submit the field's current text to the publisher's newest `onQuery`. The
+     * inbound half — what the field should SHOW — is
+     * {@link MagicBarSearchSpec.queryText}, and that asymmetry in naming is forced:
+     * this member shipped first, and renaming it would be a ds-compat MAJOR.
+     */
+    query(text: string): void;
+    openFilters(): void;
+}
+/**
+ * One view's complete claim on the magic bar.
+ *
+ * Identity (`appId` / `windowId`) is deliberately absent: it belongs to the
+ * {@link MagicBarPublisher} that was minted for this owner, so a later publish
+ * cannot re-target another app's slot.
+ */
+interface MagicBarContribution {
+    /**
+     * What the publisher is showing, e.g. `'tasks:detail'`. A change here is
+     * reset-on-navigate: the registry replaces the slot wholesale rather than
+     * reconciling, so nothing from the previous view can survive.
+     */
+    readonly viewKey: string;
+    readonly search?: MagicBarSearch | null;
+    /** Ordered clusters, separator-joined. */
+    readonly groups?: readonly MagicBarGroup[];
+    /** The accent-filled CTA ("New task", "Add signal"). */
+    readonly primary?: MagicBarAction | null;
+    /**
+     * Ids of {@link AgentCommand}s this view considers most relevant, most-relevant
+     * first — the Ask-AI menu's per-view sets.
+     *
+     * Ids, not command objects: the platform already models commands (manifest
+     * `commands[]` → `AgentCommandRegistry`), and D5 §6 item 9 is explicit that
+     * production must source these from manifests instead of the mock's hardcoded
+     * `{ title, note, prompt }` triples. Duplicating that model here would fork the
+     * palette and reintroduce hardcoded prompt text. Unknown ids are dropped by the
+     * resolver; an empty list leaves the shell's affinity ranking in charge.
+     */
+    readonly quickCommandIds?: readonly string[];
+    /** The "…" overflow set. Reserved design intent (D5 §6 item 8) — Print / Export / Settings. */
+    readonly overflow?: readonly MagicBarAction[];
+}
+/** The shell-facing projection of a contribution. See `magic-bar-projection.ts`. */
+interface MagicBarView {
+    readonly appId: string;
+    readonly windowId?: string;
+    /** {@link magicBarOwnerKey} of the publisher. */
+    readonly ownerKey: string;
+    readonly viewKey: string;
+    readonly search: MagicBarSearchView | null;
+    readonly groups: readonly MagicBarGroupView[];
+    readonly primary: MagicBarActionView | null;
+    readonly quickCommandIds: readonly string[];
+    readonly overflow: readonly MagicBarActionView[];
+}
+/**
+ * A view's handle on its magic-bar slot. Minted once per publisher (not per
+ * publish) because the publish rate is the whole point of this surface: the
+ * sibling registries hand back a handle per `register()` and expect a handful of
+ * calls per app lifetime, whereas a magic-bar publisher re-emits on every
+ * selection change. Handing out a fresh handle each time would leave the caller
+ * holding a dead one and force it to reassign on every keystroke.
+ */
+interface MagicBarPublisher {
+    readonly owner: MagicBarOwnerRef;
+    /**
+     * Replace this owner's contribution. No-op after {@link dispose}, and no-op
+     * after the shell has {@link MagicBarRegistry.clear}ed this owner key.
+     *
+     * **Publish is last-writer-wins and eviction is not** — a deliberate asymmetry.
+     * A stale publisher (one that has been replaced on this key by a newer one)
+     * cannot `dispose()` the newer one out of the slot, but it *can* still take the
+     * slot back by publishing. Symmetry would need a "newest publisher wins" rule
+     * enforced on write, which would make the first publish of a replacement
+     * publisher silently drop whenever two live views briefly share a key. The
+     * exposure is bounded: two live publishers on one owner key only happen while a
+     * view is being replaced in place, and the loser re-publishes on its next
+     * selection change. The unbounded case — a publisher that outlives its window —
+     * is closed by `clear()`'s tombstone, not by write ordering.
+     */
+    publish(contribution: MagicBarContribution): void;
+    /**
+     * Release the slot. Idempotent, and a no-op if another publisher has since
+     * taken this owner key — the same stale-handle rule the sibling registries use.
+     */
+    dispose(): void;
+}
+
+/**
+ * Cross-bundle store key + sync event.
+ *
+ * Exported for the same reason {@link FLY_REMOTE_CONTEXT_STORE_KEY} is — test
+ * isolation and devtools — but NOT as a hand-writable integration path the way
+ * that one is. Slots hold live functions, so a caller writing the slot directly
+ * would have to reproduce the projection, the fingerprint and the session
+ * bookkeeping. The DS API is the only supported writer.
+ */
+declare const FLY_MAGIC_BAR_STORE_KEY = "__flyMagicBar__";
+declare const FLY_MAGIC_BAR_EVENT = "fly:magic-bar";
+/**
+ * The magic bar's contribution store: apps publish what the top-bar pill should
+ * offer for the view they are showing, the shell renders whichever contribution
+ * belongs to the window the user is in.
+ *
+ * Why the state lives on `globalThis`
+ * -----------------------------------
+ * Same reasoning as {@link FlyRemoteContextService}, and the same direction of
+ * travel (remote → shell chrome). This service is `providedIn: 'root'`, but a
+ * root instance is not *reliably* shared across the federation boundary: the
+ * shell builds the design system from workspace source while remotes consume the
+ * published package, and Native Federation collapses those into one runtime
+ * instance only when version negotiation succeeds. That negotiation has silently
+ * split before. A split here would be invisible at build time and would present
+ * as an empty toolbar for federated apps only — exactly the class of bug
+ * `fly-federation-singleton-guard` exists to shout about. Keeping the state on
+ * the one substrate every bundle shares makes THIS store fork-proof — which
+ * contribution is published, which one is active, and the handlers behind it all
+ * survive a split — and behaves identically to a plain signal store when there
+ * isn't one. Each instance mirrors the store into signals and re-reads on the sync
+ * event, so reactivity works whichever copy published.
+ *
+ * **What this does NOT harden: the Ask-AI menu.** A contribution's
+ * `quickCommandIds` resolve against `AgentCommandRegistry`, a plain
+ * `providedIn: 'root'` singleton with no `globalThis` backing. Under a fork the
+ * toolbar therefore paints correctly while the quick-command menu comes back
+ * empty — for federated apps only. S2.3 owns that decision (resolve fork-safely,
+ * or accept the degradation deliberately); see the S1.5 note.
+ *
+ * Idempotent re-publication
+ * -------------------------
+ * A view re-publishes its whole contribution on every selection change. Only a
+ * change to the *painted* fields propagates; the handlers behind an unchanged
+ * projection are still swapped for the newest ones. `magic-bar-projection.ts`
+ * carries that argument in full — it is the single most load-bearing property of
+ * this store, and the reason `active()` can be held across dozens of publishes
+ * without re-rendering and without ever firing a stale closure.
+ *
+ * What this service does NOT own
+ * ------------------------------
+ * **Window arbitration.** The registry stores every owner's contribution and
+ * renders whichever one {@link setActiveOwner} names; deciding *which* window is
+ * active is the shell's job (focus, minimize, close — none of which the DS can
+ * see). Until the shell names one, {@link active} is `null`: an empty bar is a
+ * loud, trivially-diagnosed failure, whereas a last-publisher-wins default would
+ * paint a BACKGROUND window's Delete button into the chrome of the focused one.
+ * S2.2 wires this from the shell's focused-window signal, alongside the existing
+ * `WINDOW_ROUTE` per-window plumbing.
+ */
+declare class MagicBarRegistry {
+    private readonly _views;
+    private readonly _activeOwner;
+    private _syncedStore;
+    private _syncedRevision;
+    /**
+     * Owner key → the last publish fault already reported for it. Instance-local, not
+     * store-level: the thing being rate-limited is a throw into ONE app's
+     * `ErrorHandler`, so each realm is entitled to its own single shout.
+     */
+    private readonly _lastFault;
+    /** Every published contribution, keyed by {@link magicBarOwnerKey}. */
+    readonly all: Signal<ReadonlyMap<string, MagicBarView>>;
+    /** Owner the shell has nominated, or `null` when it has nominated none. */
+    readonly activeOwner: Signal<MagicBarOwnerRef | null>;
+    /**
+     * The contribution the shell should render.
+     *
+     * Falls back from the window-keyed slot to an `appId`-keyed one so a remote
+     * that publishes without a `windowId` still reaches the bar, then asserts the
+     * resolved view belongs to the nominated app — see {@link resolveView}, which
+     * {@link viewFor} shares so the two can never answer differently. Identity is
+     * stable while the active view's painted content is unchanged, including across
+     * publishes by OTHER windows.
+     */
+    readonly active: Signal<MagicBarView | null>;
+    constructor();
+    /**
+     * Mint a publisher for one owner. Call once per view host (component
+     * constructor), keep the result, `publish()` as often as the view changes, and
+     * `dispose()` on teardown — a `DestroyRef.onDestroy` is the intended shape.
+     *
+     * The slot is claimed on the FIRST publish, not here, so a publisher that is
+     * created and destroyed without ever publishing cannot evict whoever currently
+     * owns the key.
+     */
+    publisher(owner: MagicBarOwnerRef): MagicBarPublisher;
+    /**
+     * Force-clear an owner's slot regardless of who published it. The shell's
+     * janitor path: a window closing, or a remote that tore down without disposing,
+     * must not leave its actions painted in the chrome.
+     *
+     * Two properties the janitor depends on, both learned the hard way:
+     *
+     * 1. **It clears the `appId` fallback slot too** when a `windowId` is given. The
+     *    janitor only ever knows the closing window (`{ appId, windowId }`), while a
+     *    remote that published WITHOUT a window id — precisely the case
+     *    {@link active}'s fallback exists to serve — sits in `a:<appId>`. Clearing
+     *    only the window slot would strand that one on `globalThis`, holding
+     *    `onSelect` closures that retain a destroyed component tree, and the shell
+     *    would paint the dead window's toolbar the next time the app opened.
+     *    The cost is deliberate, and PERMANENT for publishers minted before this
+     *    call: with two windows of one app open and only the windowId-less fallback
+     *    published, closing either revokes the fallback key at the current session
+     *    watermark — which the survivor's session is necessarily under — so the
+     *    survivor's future publishes are dropped too, for the rest of its life, not
+     *    merely until its next publish. That is not fixable with a smarter
+     *    watermark: two publishers sharing the fallback key are indistinguishable
+     *    at clear time (the janitor knows which WINDOW closed, not which SESSION
+     *    was publishing on the shared key), so any cutoff that reliably kills the
+     *    closing window's zombie can also kill the survivor. An empty bar is the
+     *    safe state (see {@link active}); recovery needs a publisher minted AFTER
+     *    the clear — a reopened window, or `publisherFor` called fresh. The real
+     *    lesson: a multi-window app should pass `windowId` and get its own slots.
+     * 2. **It is a tombstone, not a delete.** `WindowManagerService.closeWindow`
+     *    marks the window `isClosing` and removes it 250 ms later, so the component
+     *    — and the `effect()` that publishes for it — outlives the janitor. A plain
+     *    delete leaves the publisher's own `disposed` flag false, so its next run
+     *    re-claims the key and a zombie contribution survives until `DestroyRef`
+     *    fires. Every publisher minted before this call is revoked permanently; one
+     *    minted after (a reopened window) owns the key normally.
+     */
+    clear(owner: MagicBarOwnerRef): void;
+    /**
+     * Nominate the owner whose contribution {@link active} resolves to. `null`
+     * hands the bar back to the shell's own default (search only).
+     */
+    setActiveOwner(owner: MagicBarOwnerRef | null): void;
+    /**
+     * Direct, non-reactive read of one owner's contribution — the split-proof
+     * escape hatch for callers outside an injection/reactive context. Applies the
+     * SAME resolution as {@link active}, fallback included.
+     */
+    viewFor(owner: MagicBarOwnerRef): MagicBarView | null;
+    private write;
+    /**
+     * Surface a publish fault LOUDLY on its first occurrence for an owner, then stay
+     * quiet until the fault changes or a good publish lands.
+     *
+     * The sibling precedent (`AgentCommandRegistry.registerAll`) throws on a
+     * once-per-boot path, so throwing outright is proportionate there. Here the
+     * intended wiring is `effect(() => this.bar.publish(this.contribution()))`, so a
+     * single duplicate action id would otherwise throw on EVERY selection change
+     * forever — an unbounded stream of `ErrorHandler` toasts that buries the one
+     * report the developer needed. Rethrowing the first occurrence keeps the loudest
+     * possible signal (a real stack, through the app's own `ErrorHandler`); the
+     * repeats are dropped, not the bug. A different fault message, or a recurrence
+     * after a good publish, is loud again.
+     */
+    private reportFaultOnce;
+    private drop;
+    /**
+     * Late binding of invokers to the newest publish. Closes over the owner key
+     * only — never over a slot — so it survives every replacement, including one
+     * written by another federated copy of this service.
+     */
+    private handlerSource;
+    /**
+     * Re-read the shared store. Cheap no-op unless a real mutation landed.
+     *
+     * The memo keys on store IDENTITY as well as revision: the revision counter
+     * alone cannot distinguish "nothing changed" from "the `globalThis` slot now
+     * holds a brand-new store that happens to be at the same revision". That is not
+     * hypothetical — every spec's `beforeEach` replaces the store, and instances
+     * from earlier tests are still subscribed (a `providedIn: 'root'` service has no
+     * teardown hook for its `globalThis` listener, matching `FlyRemoteContextService`).
+     */
+    private sync;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagicBarRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MagicBarRegistry>;
+}
+
+/**
+ * The precedence rule for {@link MagicBarSearchSpec.queryText}, authored once.
+ *
+ * ## The problem
+ * The magic bar's search field has two writers. The **user** types into it, and the
+ * **publisher** can move it — a deep link arriving with `?q=…`, a restored session,
+ * a filter applied from a detail pane. Neither can be made subordinate to the other
+ * by fiat:
+ *
+ *  - Make the publisher's value authoritative on every emitted view and you get the
+ *    classic controlled-input bug. The dominant re-publish in this contract is
+ *    `disabled: !hasSelection` flipping on a selection change, which changes the
+ *    fingerprint and therefore emits a new view carrying the SAME `queryText`. A
+ *    renderer that re-read it would revert the user's keystroke every time they
+ *    clicked a row mid-search.
+ *  - Make the field authoritative once the user has touched it and a legitimate
+ *    publisher-initiated change — the deep link this field exists for — silently
+ *    fails to land.
+ *
+ * ## The rule
+ * `queryText` is a **seed, not a controlled value**. The field adopts it exactly
+ * three times: on first bind, on a `viewKey` change (reset-on-navigate), and when
+ * the published value itself changes from the previously published one. Everything
+ * else leaves the field alone.
+ *
+ * That is what {@link magicBarSearchText} computes. It is a pure function of
+ * (previous publisher state, next publisher state) — deliberately NOT a function of
+ * the field's current text, because whether to adopt must not depend on what the
+ * user happens to have typed. A publisher re-publishing `queryText: 'open'` must
+ * re-assert it identically whether the field currently reads `'open'`, `'opened'`
+ * or `''`.
+ *
+ * ## Why this lives in the design system rather than in the shell
+ * Same reasoning as `clampMagicBarSearchWidth`: the DS does not ship the magic-bar
+ * search-field renderer (the shell composes `fly-search-input` itself, and D5 §4
+ * dynamic 6 has a mobile bar rendering the same contribution), but the rule is part
+ * of the CONTRACT, not of any one renderer. Documented-but-unimplemented precedence
+ * would be re-derived per renderer, and the two would disagree on exactly the case
+ * that is hard to notice.
+ */
+/**
+ * The publisher-side inputs the field's text is seeded from — the two fields
+ * {@link magicBarSearchText} compares, lifted out of {@link MagicBarView} so a
+ * renderer can retain them without retaining a whole view (and with it every
+ * `run()` closure behind it).
+ */
+interface MagicBarSearchSeed {
+    /** {@link MagicBarContribution.viewKey} of the contribution being rendered. */
+    readonly viewKey: string;
+    /**
+     * {@link MagicBarSearchSpec.queryText}. `undefined` (the view does not manage the
+     * field) and `''` (clear it) are different values and must be passed through as
+     * such — do not normalise one into the other before calling.
+     */
+    readonly queryText?: string;
+}
+/**
+ * The text the field must be forced to, or `null` to leave whatever the user has
+ * typed in place.
+ *
+ * `previous` is the seed from the last publish the renderer saw — `null` on first
+ * bind. Store `next` as the new `previous` on every call, whether or not this
+ * returned a string: the comparison is against the last value the PUBLISHER sent,
+ * not against the last value the field adopted, and conflating the two makes an
+ * A → B → A publish sequence stop re-asserting A.
+ *
+ * A view with no search at all never reaches here — the renderer has nothing to
+ * seed. A view whose search omits `queryText` still seeds `''` on navigate, which
+ * is the reset-on-navigate behaviour the contract already required.
+ *
+ * Within an unchanged view, the three transitions behave differently on purpose
+ * (S2 review finding 1 — the model doc is the contract, and it says absent means
+ * "this view does not manage the field; nothing is ever forced"):
+ *
+ *   `'a' → 'b'`        force `'b'`   — the publisher changed a value it manages
+ *   `undefined → ''`   force `''`    — the publisher STARTED managing, asking for a clear
+ *   `'a' → undefined`  leave alone   — the publisher STOPPED managing; forcing `''`
+ *                                      here is the controlled-input revert bug: a view
+ *                                      that seeds from `?q=` and naturally omits the
+ *                                      field when no query param exists would wipe the
+ *                                      user's typed text on its next disabled-flip
+ *                                      re-publish
+ */
+declare function magicBarSearchText(previous: MagicBarSearchSeed | null, next: MagicBarSearchSeed): string | null;
+
+/**
+ * Allowlist parser for {@link MagicBarActionSpec.iconPath} — the geometry-only
+ * gate between a publisher-supplied glyph fragment and the DOM.
+ *
+ * ## Why this exists rather than a sanitizer call
+ *
+ * `iconPath` is inner-SVG markup (see `magic-actions-icons.ts`), and it used to
+ * reach the DOM through `[innerHTML]` + `DomSanitizer.bypassSecurityTrustHtml()`.
+ * Two facts make that untenable:
+ *
+ * 1. An `<svg>` fragment is not a closed world. `<foreignObject>` is an HTML
+ *    integration point, so `<foreignObject><img src=x onerror=…>` executes;
+ *    `<a xlink:href="javascript:…">` wrapping the glyph is live under a click
+ *    the user is being invited to make; `on*` handlers and `<style>` need no
+ *    integration point at all.
+ * 2. `DomSanitizer.sanitize(SecurityContext.HTML, …)` is not the answer either:
+ *    Angular's HTML element allowlist contains no SVG shape elements, so it
+ *    strips `<path>`/`<circle>`/`<rect>` along with the attack — every glyph in
+ *    the curated table would render empty. Sanitizing HTML is the wrong tool for
+ *    an SVG payload.
+ *
+ * Making `iconPath` the bare `d` attribute its name suggests was considered and
+ * rejected: 11 of the 22 curated entries are multi-element (`<circle>+<path>`,
+ * `<rect>+<path>…`), several ported byte-verbatim from the UX drop, so a single
+ * `d` cannot express them without re-authoring geometry — and narrowing a public
+ * `string` field's meaning is exactly the ds-compat MAJOR that 1.8.0 freezes.
+ *
+ * So the field keeps its type and its markup transport, and the RENDERER stops
+ * trusting it: this module parses the fragment against a closed element/
+ * attribute/value allowlist and hands the component structured nodes, which the
+ * template binds as real Angular attributes. No `innerHTML`, no sanitizer
+ * bypass, no HTML parser anywhere in the path — an attribute binding cannot
+ * introduce an element or a handler, so injection is structurally impossible
+ * rather than filtered.
+ *
+ * ## Reject, never strip
+ *
+ * Any violation drops the ENTIRE fragment. This mirrors `Fly.Sdk.Svg`'s
+ * server-side reject-on-violation policy, and it is the safer failure mode for a
+ * toolbar: a half-rendered glyph looks like it worked, so nobody investigates. A
+ * rejected glyph renders as an empty 16px box on a button whose accessible name
+ * and behaviour are untouched, and logs once.
+ */
+/** Elements a glyph may contain — pure geometry, no containers, no references. */
+declare const FLY_MAGIC_BAR_ICON_ELEMENTS: readonly ["path", "circle", "rect", "ellipse", "line", "polyline", "polygon"];
+type FlyMagicBarIconElement = (typeof FLY_MAGIC_BAR_ICON_ELEMENTS)[number];
+/** One allowlisted element and its allowlisted attributes, ready to bind. */
+interface FlyMagicBarIconNode {
+    readonly tag: FlyMagicBarIconElement;
+    readonly attrs: Readonly<Record<string, string>>;
+}
+
+/** Design range for {@link MagicBarSearchSpec.openWidth} (D2 §3.1) — see {@link clampMagicBarSearchWidth}. */
+declare const MAGIC_BAR_SEARCH_WIDTH_MIN = 140;
+declare const MAGIC_BAR_SEARCH_WIDTH_MAX = 420;
+declare const MAGIC_BAR_SEARCH_WIDTH_DEFAULT = 230;
+/**
+ * Clamp a {@link MagicBarSearchSpec.openWidth} hint to the design's documented
+ * range. `magic-bar.model.ts` deliberately does not validate this field itself
+ * (rejecting a whole contribution over a cosmetic hint would be worse than a
+ * clamp) and names `fly-magic-actions` as "the only place that decides what an
+ * out-of-range or non-finite value means".
+ *
+ * `fly-magic-actions` does not render the search field itself — search is a
+ * separate DS component (D2 §3.1's `SearchField`, not yet ported) — but until
+ * that renderer ships, this is the one place the clamp rule is authored, so a
+ * future consumer imports it instead of re-deriving the 140–420/230 constants.
+ */
+declare function clampMagicBarSearchWidth(width: number | undefined): number;
+/**
+ * `<fly-magic-actions>` — renders the magic bar's dynamic action cluster: an
+ * ordered set of {@link MagicBarGroupView}s (framed tab-actions, plain
+ * record-actions, separator-joined), each action icon-only/text/toggle, with the
+ * Status/Sort `menuitemradio` pattern where an action carries a `menu`, plus the
+ * optional accent `primary` CTA.
+ *
+ * ## Why `primary` lives here (reversing half the S1.4 ruling)
+ * This component originally rendered `groups` only, on the reasoning that the
+ * accent CTA is a visually distinct, separately-composed element. First contact
+ * with a real consumer (`features/desktop/magic-bar/magic-bar-pill`) showed that
+ * reasoning costs more than it saves, because {@link parseMagicBarIcon} — the
+ * closed-allowlist parser that makes a publisher's `iconPath` safe to render — is
+ * internal to this component. A composer outside it has no way to draw a
+ * contributed glyph at all, so `primary` had to be smuggled back in as a
+ * synthetic one-item group: an invented group id, an invented group `labelKey`,
+ * and a spurious `role="group"` wrapped around a single button, announced to a
+ * screen-reader user as a group of one. Every place a CONTRIBUTED glyph is
+ * painted now lives in the component that owns the parser.
+ *
+ * ## What is still NOT rendered here, and why
+ * - **The search field** — a separate DS component (D2 §3.1's `SearchField`); this
+ *   file owns only its width rule, {@link clampMagicBarSearchWidth}.
+ * - **The Ask-AI orb** — shell chrome keyed on `quickCommandIds`, no glyph of the
+ *   publisher's.
+ * - **The `overflow` kebab** — and this one is a deliberate *deferral*, not a
+ *   boundary. Its rows would render through `fly-context-menu`, whose
+ *   `ContextMenuItem` carries `icon` as a PrimeIcons CLASS NAME and has no
+ *   `disabled`; so an overflow action's `iconPath` cannot be painted and a
+ *   disabled overflow row cannot be shown as disabled, wherever the kebab is
+ *   composed. Moving it here would relocate that limitation rather than remove
+ *   it, while making this component own a "More actions" string it cannot ship
+ *   into the shell bundle on its own. The prerequisite is two optional fields on
+ *   `ContextMenuItem`; see the S2.13 note.
+ *
+ * ## What this component must never do (S1.5 contract, `MagicBarRegistry`)
+ * - **Never cache `run()`/`select()`.** They are late-bound invokers — read fresh
+ *   off the `MagicBarActionView`/`MagicBarRadioMenuView` on every call, never
+ *   captured into a local variable that outlives the click.
+ * - **Never reach for a publisher's `onSelect`.** Only the projected view's
+ *   `run()`/`menu.select()` exist on the types this component accepts.
+ *
+ * ## The stagger guard
+ * `toolbarPopIn` (40 ms/action) is a static `animation:` on `.fma-btn`, replayed
+ * only when the browser creates a NEW element — never on a property-only
+ * re-render of a persisted one. `@for (…; track action.id)` is what makes that
+ * true: `action.id` is unique across the WHOLE contribution — `primary` included
+ * (the model's own invariant) — so a re-publish that only flips
+ * `disabled`/`pressed`/`badgeDot` on existing ids reuses the same DOM nodes and
+ * the finished animation is left alone. A re-publish whose group genuinely
+ * gains/loses ids creates/destroys the corresponding elements, and only THOSE
+ * replay. Do not `track $index` — that defeats this and re-pops the whole group
+ * on every selection change.
+ *
+ * `primary` sits in its own single-child wrapper rather than directly in the row,
+ * so `nova-stagger`'s `:nth-child` arithmetic gives it a fixed delay instead of
+ * one that shifts with how many framed groups (and therefore separators) happen
+ * to precede it.
+ */
+declare class FlyMagicActionsComponent {
+    protected readonly i18n: I18nService;
+    /** Ordered clusters — framed tab-actions before plain record-actions (D2 §2.3). */
+    readonly groups: _angular_core.InputSignal<readonly MagicBarGroupView[]>;
+    /**
+     * The accent-filled CTA ("New task", "Add signal"), or `null`. Optional: a view
+     * that offers no primary action passes nothing, and no accent disc is painted.
+     */
+    readonly primary: _angular_core.InputSignal<MagicBarActionView | null>;
+    /** Id of the action whose radio menu is open, or `null`. Only one open at a time. */
+    protected readonly openMenuActionId: _angular_core.WritableSignal<string | null>;
+    private readonly menuAnchor;
+    protected readonly menuAnchorEl: _angular_core.Signal<HTMLElement | null>;
+    /** The scrolling group row — the box {@link measure} interrogates. Absent while `groups` is empty. */
+    private readonly rowRef;
+    /**
+     * The action whose radio menu is open, resolved against the CURRENT projection
+     * rather than captured when the menu opened — so a re-publish that
+     * changes the menu's `value`/`options` while it is open renders the new state,
+     * and one that drops the action entirely closes the menu instead of leaving an
+     * orphan bound to a stale view.
+     *
+     * Exists because the menu is rendered once, outside the group loops (S1-review
+     * F9): a `<fly-context-menu>` inserted beside its button would shift every
+     * later `.fma-btn`'s `:nth-child` index and with it its stagger delay.
+     */
+    protected readonly openAction: _angular_core.Signal<MagicBarActionView | null>;
+    /**
+     * When the open action leaves the projection, ACTUALLY close — do not merely
+     * stop rendering (S2 review finding 4). Left set, `openMenuActionId` +
+     * `menuAnchor` are a re-open trap: a later publish that re-adds the same id
+     * would resurrect the menu with no user action, anchored to an element the
+     * `@for (…; track action.id)` has since destroyed — undefined placement plus
+     * a retained DOM node. The effect fires on the same projection change that
+     * un-rendered the menu, so there is no frame in between to observe.
+     */
+    private readonly closeWhenActionLeaves;
+    /**
+     * True once the GROUP row's content no longer fits its container. Drives the
+     * fade-mask + horizontal-scroll treatment (house style: "icon-only toolbars
+     * with horizontal-ellipsis overflow, never a second row" — skill §9 rule 6).
+     * Buttons stay reachable by scroll/Tab rather than being clipped-and-hidden.
+     *
+     * Only the groups scroll. `primary` sits outside `.fma` precisely so the fade
+     * can never reach it: a call to action that dissolves into a gradient, or that
+     * has to be scrolled to, is the opposite of an overflow affordance.
+     */
+    protected readonly isOverflowing: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /**
+     * Identity function that types the `#actionButton` template's context.
+     *
+     * `NgTemplateOutlet` gives a template no context type — `let-projected` is
+     * `any` — and Angular has no declarative way to annotate one. Passing it through
+     * here and binding the result with `@let` makes every read inside that block
+     * (`.kind`, `.disabled`, `.menu`) type-checked again. The alternative was
+     * duplicating the block per call site, which trades a checked template for an
+     * unchecked copy of the security-critical glyph binding.
+     */
+    protected asAction(action: MagicBarActionView): MagicBarActionView;
+    /** `i18n.t(labelKey, labelParams)` — the resolved, interpolated label text. */
+    protected resolvedLabel(action: MagicBarActionView): string;
+    /**
+     * The tooltip text. Disabled ⇒ `disabledTipKey` verbatim, or the auto-suffixed
+     * `"{label} — {reason}"` — the connector + default reason are the renderer's
+     * job precisely because the store only holds i18n keys (never resolved text,
+     * never a locale decision baked in). Enabled ⇒ `tipKey` override, else the
+     * label itself.
+     */
+    protected tooltipFor(action: MagicBarActionView): string;
+    /**
+     * Accessible name for a radio-menu trigger — richer than the plain label so a
+     * screen-reader user hears the current value without opening the menu
+     * ("Sort by: Newest first"), matching the visual badge-dot affordance.
+     */
+    protected triggerAriaLabel(action: MagicBarActionView): string;
+    /**
+     * The glyph's allowlisted geometry nodes, which the template binds as real
+     * attributes on real `<svg:*>` elements.
+     *
+     * `iconPath` is publisher-supplied markup and is NOT trusted: this used to be
+     * `bypassSecurityTrustHtml()` into `[innerHTML]`, which made an SVG fragment's
+     * escape hatches (`<foreignObject>` → HTML integration point, `<a
+     * xlink:href="javascript:…">`, `on*` handlers, `<style>`) live inside the
+     * shell's own chrome. See `magic-actions-icon.ts` for why sanitizing the HTML
+     * was not an option (Angular's HTML allowlist has no SVG shapes, so it strips
+     * every glyph) and why `iconPath` could not become a bare `d`.
+     *
+     * `parseMagicBarIcon` memoizes, so this is safe to call from the template on
+     * every change-detection pass AND returns a stable array identity, which is
+     * what stops `@for (…; track $index)` rebuilding the glyph each time.
+     */
+    protected iconNodes(action: MagicBarActionView): readonly FlyMagicBarIconNode[];
+    /** `null` (not `'default'`) so `[attr.data-tone]` omits the attribute entirely for the common case. */
+    protected toneAttr(action: MagicBarActionView): string | null;
+    /**
+     * A radio-menu trigger derives its badge from the menu spec itself
+     * (`value !== defaultValue`) rather than trusting a separately-set
+     * `badgeDot` — the menu already carries both fields precisely for this
+     * comparison, and deriving it here can't drift out of sync with a publisher
+     * that forgets to keep the two in step. An action with no menu falls back to
+     * the authored `badgeDot` verbatim.
+     */
+    protected hasBadge(action: MagicBarActionView): boolean;
+    /** `aria-pressed` for `kind: 'toggle'` only — omitted (not `false`) for every other kind. */
+    protected pressedAttr(action: MagicBarActionView): boolean | null;
+    protected menuSections(action: MagicBarActionView): ContextMenuSection[];
+    protected activate(action: MagicBarActionView, event: Event): void;
+    protected onMenuAction(action: MagicBarActionView, value: string): void;
+    protected closeMenu(): void;
+    private toggleMenu;
+    /**
+     * Toggle {@link isOverflowing} when `.fma`'s content stops fitting. CSS alone
+     * can't express "is this scrollable" as a selector, and a fixed always-on fade
+     * would mislead when the row already fits — so the check has to run in JS.
+     *
+     * ## What this measures, and what it used to measure
+     * The scroll box is `.fma`, NOT the host. The host is a plain flex container
+     * whose in-flow children are `.fma` (which clips its OWN overflow) and the
+     * primary wrapper — so the host's scrollable overflow area is exactly its
+     * content box and `scrollWidth - clientWidth` is structurally always 0. It was
+     * measured on the host before this change, where the fade mask could never
+     * engage no matter how badly the row overflowed. Nothing failed: the feature was
+     * simply inert, and jsdom performs no layout so no unit test could see it.
+     *
+     * ## Two passes, both needed
+     * `ResizeObserver` catches the box changing under fixed content (window resize,
+     * the pill sharing space with a longer search field). It does NOT fire when the
+     * CONTENT changes inside a box that is already clamped at its maximum — a
+     * re-publish that adds an action to a row that exactly fitted. That is what the
+     * `afterRenderEffect` covers, and it must be an after-RENDER pass: the `effect`
+     * below re-targets the observer as `.fma` mounts, but it runs before the browser
+     * has laid the new content out, so a measurement there reads the previous frame.
+     * Same split, same reasoning as `board-editor-chrome-metrics.ts`.
+     *
+     * `ResizeObserver` is optional — absent (Node/jsdom) the after-render pass still
+     * runs and reads 0s, which reports "not overflowing" rather than throwing.
+     */
+    private watchOverflow;
+    private measure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyMagicActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyMagicActionsComponent, "fly-magic-actions", never, { "groups": { "alias": "groups"; "required": true; "isSignal": true; }; "primary": { "alias": "primary"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Curated stroke-icon table for magic-bar actions (D2 §2, D5 §1.6/§1.9).
+ *
+ * A value is **inner SVG markup only** — one or more `<path>`/`<circle>`/`<rect>`
+ * fragments with no wrapping `<svg>` tag. `fly-magic-actions` supplies the shell
+ * (`viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8"
+ * stroke-linecap="round" stroke-linejoin="round"`) — matches
+ * `ToolbarActions.dc.html`'s own transport ("raw SVG inner markup rendered into a
+ * 24×24 viewBox … svg").
+ *
+ * `MagicBarActionSpec.iconPath` accepts ANY string — a publisher is free to author
+ * its own glyph — but without a shared table, every app hand-authors `M4 4h16…`
+ * literals with inconsistent stroke widths and no dedupe. This is that table.
+ * Reference by name: `iconPath: FLY_MAGIC_BAR_ICONS.trash`.
+ *
+ * Provenance is marked per group below. The first group is ported verbatim (byte-
+ * identical geometry) from the UX drop so real shipped surfaces keep their exact
+ * look; the second is original, same-convention artwork for named actions the drop
+ * doesn't expose as a standalone path. Swap an "original" entry for a sourced one
+ * if a verbatim path turns up later — this table is additive, not frozen.
+ */
+/**
+ * The full curated table. Publishers reference it by name
+ * (`iconPath: FLY_MAGIC_BAR_ICONS.trash`); nothing stops passing an arbitrary
+ * string instead — {@link MagicBarActionSpec.iconPath} stays `string`.
+ */
+declare const FLY_MAGIC_BAR_ICONS: {
+    /** Signal-detail "View trace" — no standalone path in the drop; an activity/pulse line. */
+    readonly viewTrace: "<path d=\"M3 12h4l2-7 4 14 2-7h6\"/>";
+    /** Signal-detail "Archive". */
+    readonly archive: "<rect x=\"3\" y=\"4\" width=\"18\" height=\"4\" rx=\"1\"/><path d=\"M5 8v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8\"/><path d=\"M10 13h4\"/>";
+    /** Task-list "Sort by" trigger. */
+    readonly sort: "<path d=\"M7 4v16\"/><path d=\"M3 8l4-4 4 4\"/><path d=\"M17 20V4\"/><path d=\"M13 16l4 4 4-4\"/>";
+    /** Task-detail "Add audience". */
+    readonly addAudience: "<circle cx=\"9\" cy=\"7\" r=\"3.2\"/><path d=\"M2.5 19.4a6.5 6.5 0 0 1 13 0\"/><path d=\"M16 10.5a3 3 0 1 0 0-5.8\"/><path d=\"M18.5 19.4a5.6 5.6 0 0 0-3-5\"/>";
+    /** Task-detail "Add tag". */
+    readonly addTag: "<path d=\"M20 13.5 12.5 21a2 2 0 0 1-2.8 0L4 15.3a2 2 0 0 1 0-2.8L11.5 5H18a2 2 0 0 1 2 2v6.5Z\"/><circle cx=\"15\" cy=\"9\" r=\"1.4\"/>";
+    /** Task-detail "Assign robot". */
+    readonly assignRobot: "<rect x=\"4\" y=\"8\" width=\"16\" height=\"11\" rx=\"3\"/><path d=\"M12 8V4\"/><circle cx=\"12\" cy=\"3\" r=\"1.2\"/><path d=\"M8 13v2M16 13v2\"/>";
+    /** Task-detail "Add subtask". */
+    readonly addSubtask: "<path d=\"M9 6h11M9 12h11M9 18h7\"/><path d=\"M4 6h.01M4 12h.01\"/><path d=\"M4.5 16h3M6 14.5v3\"/>";
+    /** `UX/FlyOS Desktop-app/MainContent.dc.html:927` (`pubTabActions`'s local `P` table). */
+    readonly addEvidence: "<path d=\"M10.5 13.5a4 4 0 0 0 5.7 0l2-2a4 4 0 0 0-5.7-5.7l-.6.6\"/><path d=\"M13.5 10.5a4 4 0 0 0-5.7 0l-2 2a4 4 0 0 0 4.2 6.5\"/><path d=\"M17.5 15.5v5M15 18h5\"/>";
+    /** `MainContent.dc.html:928`. Reused for every "Edit …" action (evidence, link, task). */
+    readonly edit: "<path d=\"M4 20h4.2L19 9.2a2 2 0 0 0 0-2.8l-1.4-1.4a2 2 0 0 0-2.8 0L4 15.8V20z\"/><path d=\"M13.5 6.5l4 4\"/>";
+    /** `MainContent.dc.html:929`. Circle-minus — "Remove evidence", distinct from the full-trash `delete`. */
+    readonly remove: "<circle cx=\"12\" cy=\"12\" r=\"8.6\"/><path d=\"M8.2 12h7.6\"/>";
+    /** `MainContent.dc.html:930`. */
+    readonly unlink: "<path d=\"M9.6 14.4l-1.4 1.4a3.8 3.8 0 0 1-5.4-5.4l1.9-1.9\"/><path d=\"M14.4 9.6l1.4-1.4a3.8 3.8 0 0 1 5.4 5.4l-1.9 1.9\"/><path d=\"M4.8 4.8l14.4 14.4\"/>";
+    /** `MainContent.dc.html:931`. */
+    readonly link: "<path d=\"M10.5 13.5a4 4 0 0 0 5.7 0l2.6-2.6a4 4 0 0 0-5.7-5.7l-1 1\"/><path d=\"M13.5 10.5a4 4 0 0 0-5.7 0l-2.6 2.6a4 4 0 0 0 5.7 5.7l1-1\"/>";
+    /** `Home.dc.html:619` — the `+` glyph ("Add signal" / "Add trend" / New-task CTA). */
+    readonly add: "<path d=\"M12 5v14M5 12h14\"/>";
+    /** `Home.dc.html:445`. */
+    readonly filter: "<path d=\"M4 6h16M7 12h10M10 18h4\"/>";
+    /** `Home.dc.html:613`. */
+    readonly export: "<path d=\"M12 16V7M8 11l4-4 4 4\"/><path d=\"M4 15v3a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-3\"/>";
+    /** `Home.dc.html:616`. */
+    readonly import: "<path d=\"M12 4v9M8 9l4 4 4-4\"/><path d=\"M4 15v3a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-3\"/>";
+    /** `Home.dc.html:547` — "Mark as complete". */
+    readonly check: "<circle cx=\"12\" cy=\"12\" r=\"8.6\"/><path d=\"M8.4 12.3l2.6 2.6 4.6-5\"/>";
+    /** `Home.dc.html:550` — "Watch task". */
+    readonly watch: "<path d=\"M2.5 12S6 5.8 12 5.8 21.5 12 21.5 12 18 18.2 12 18.2 2.5 12 2.5 12z\"/><circle cx=\"12\" cy=\"12\" r=\"2.8\"/>";
+    /** `Home.dc.html:553` — the full trash-can; the danger "Delete" family. */
+    readonly trash: "<path d=\"M4.5 7h15\"/><path d=\"M9.5 7V5.2h5V7\"/><path d=\"M6.5 7l.8 12a1.8 1.8 0 0 0 1.8 1.7h5.8a1.8 1.8 0 0 0 1.8-1.7L17.5 7\"/><path d=\"M10.5 11v6M13.5 11v6\"/>";
+    /** `Home.dc.html:969`. */
+    readonly close: "<path d=\"M6 6l12 12M18 6L6 18\"/>";
+    /** `Home.dc.html:1090` — calendar's settings-gear `pageActions` entry. */
+    readonly settings: "<circle cx=\"12\" cy=\"12\" r=\"3\"/><path d=\"M19.4 13a7.4 7.4 0 0 0 0-2l2-1.5-2-3.5-2.4.7a7.4 7.4 0 0 0-1.7-1L15 3h-4l-.3 2.7a7.4 7.4 0 0 0-1.7 1l-2.4-.7-2 3.5L6.6 11a7.4 7.4 0 0 0 0 2l-2 1.5 2 3.5 2.4-.7a7.4 7.4 0 0 0 1.7 1L11 21h4l.3-2.7a7.4 7.4 0 0 0 1.7-1l2.4.7 2-3.5-2-1.5z\"/>";
+    /** `Home.dc.html:1151` — calendar-with-check, the "Today" text action's glyph. */
+    readonly today: "<path d=\"M3.5 8.5h17M7 3.2v3.4M17 3.2v3.4\"/><rect x=\"3.5\" y=\"5.5\" width=\"17\" height=\"15\" rx=\"2.6\"/><path d=\"M8 13l2.2 2.2L14 11\"/>";
+};
+type FlyMagicBarIconName = keyof typeof FLY_MAGIC_BAR_ICONS;
+
 /**
  * Single canonical way to declare a drag source for the agent input.
  *
@@ -7345,13 +8454,36 @@ type FlyTooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
  * is `pointer-events: none` so it never eats a click or intercepts the hover.
  *
  * ## Theming + RTL
- * The surface is styled from desktop-shell tokens that carry BOTH light and dark
- * values (`--glass-bg-elevated`, `--surface-border`/`--separator`, `--text-color`/
- * `--label-primary`), with a self-consistent dark-surface + light-text fallback for
- * bare standalone usage where the DS theme layer isn't present. Placement is mirrored
+ * The surface is Nova's `--mat-tip-a`/`-b` material (skill §4) — a two-stop gradient
+ * that carries BOTH light and dark values (`_nova-tokens.scss`, `html.light-theme` /
+ * `html.dark-theme`), with a self-consistent dark-plate + white-text literal fallback
+ * for bare standalone usage where no DS theme layer is present. Placement is mirrored
  * under `dir="rtl"` (a requested `left` lands on the reading-end side) and text aligns
  * to the logical start. Honours `prefers-reduced-motion`.
  *
+ * ## Why this stays opaque, no `backdrop-filter` (read before adding blur)
+ * A body-parented tooltip can land over ANY backdrop — a light app surface, a dark
+ * canvas, the wallpaper — and it used to inherit `--glass-bg-elevated`, a TRANSLUCENT,
+ * wallpaper-adaptive fill the shell recomputes at `:root` from the current wallpaper's
+ * luminance, independent of `<html>`'s own light/dark theme class. Under a dark
+ * wallpaper it became a ~54%-alpha dark plate even while the page was `light-theme`;
+ * composited over a light surface (~rgb(143,141,140)) the paired white ink landed at
+ * ~2.8:1 — "tooltips are white-on-white in the light theme" (commit 7aa921690, 2026-08-
+ * 04). The directive's OWN doc comment at the time claimed a fallback existed; it
+ * didn't — the `var()`s carried none, so the failure was silent until measured live.
+ *
+ * `--mat-tip-a`/`-b` do not reproduce that failure class: they are keyed on
+ * `html.light-theme` / `html.dark-theme` directly (fixed per THEME), never recomputed
+ * from the wallpaper at runtime, so the plate always matches the theme the page is
+ * actually in. The residual risk — a light plate over a coincidentally dark LOCAL
+ * backdrop (not the wallpaper) — only softens the plate/backdrop edge; the near-opaque
+ * alpha (80–86%, D3 §1.6) keeps the ink-on-plate contrast itself unaffected, unlike the
+ * ~2.8:1 failure above where the FILL's own colour was wrong. This is also why no
+ * `backdrop-filter` is added here even though the material recipe allows it elsewhere:
+ * the ratified design spec forces tooltips opaque and suppresses blur outright (D1 §7
+ * item 10 / D3 §"Tooltips: ... fixed near-opaque fills"), so this file matches that
+ * intentionally rather than reaching for a `glass.popover()`-style thin blur tier.
+ *
  * The tip text is caller-supplied and assumed already-localized — no baseline i18n
  * strings are shipped.
  */
@@ -8095,6 +9227,204 @@ declare class FlyPeoplePickerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyPeoplePickerComponent, "fly-people-picker", never, { "searchFn": { "alias": "searchFn"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "excludeIds": { "alias": "excludeIds"; "required": false; "isSignal": true; }; "initialSelection": { "alias": "initialSelection"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
 }
 
+/**
+ * One ISO 4217 currency as the selector renders it.
+ *
+ * `code` is the identity: it is what {@link FlyCurrencySelectorComponent} emits and
+ * what a record should persist — never the row's database id, which is an
+ * implementation detail of whichever service served it.
+ */
+interface FlyCurrency {
+    /** ISO 4217 alpha-3 code (`AED`, `USD`, `XOF`). Unique. */
+    readonly code: string;
+    /** Display name, already resolved to the caller's locale by the server. */
+    readonly name: string;
+    /** Display symbol (`$`, `€`, `د.إ`). NOT unique — several currencies share `$`, which is exactly why every row also shows its code. */
+    readonly symbol: string;
+    /**
+     * ISO 4217 minor-unit exponent: 0 (JPY, KRW, the CFA francs), 2 (most), or 3
+     * (BHD, IQD, JOD, KWD, LYD, OMR, TND). Carried through so a host formatting the
+     * amount next to the picked currency doesn't have to assume 2 and misprice a dinar.
+     */
+    readonly decimalDigits: number;
+    /**
+     * Issuing country's flag emoji, or null/absent for the multi-country union
+     * currencies (XAF/XOF/XPF/XCD). The component degrades to a code tile either way —
+     * see {@link FlyCurrencySelectorComponent} on why the emoji alone is not enough.
+     */
+    readonly flag?: string | null;
+    /** Optional ISO 3166 alpha-2 codes of the countries using it, when the host fetched the richer `/api/currencies` shape. Purely informational. */
+    readonly countryCodes?: readonly string[];
+}
+/** Single pick (replaces the selection, value is `string | null`) vs multi pick (chips accumulate, value is `string[]`). */
+type FlyCurrencySelectorMode = 'single' | 'multi';
+/**
+ * Host-supplied loader, for a consumer that must not hit `/api/currencies/brief`
+ * directly — an offline surface, a fixture-driven test, or an app that proxies
+ * reference data through its own gateway route.
+ */
+type FlyCurrencyFetchFn = () => Observable<readonly FlyCurrency[]>;
+/** The control's value: the picked code in single mode, the picked codes in multi mode. */
+type FlyCurrencySelectorValue = string | readonly string[] | null;
+
+/**
+ * **`fly-currency-selector`** — pick one currency or several from the platform's ISO 4217
+ * catalogue, showing each with its flag, code, symbol and localized name.
+ *
+ * Pre-canned for the Controller's `GET /api/currencies/brief` (`CurrencyBriefDto`): with no
+ * data inputs it loads that endpoint itself through the host's `HttpClient`, so the gateway
+ * routing and auth interceptor apply and a consuming app writes one tag and nothing else.
+ * A host that must not reach the platform directly supplies `[currencies]` (static rows) or
+ * `[fetchFn]` (its own loader) instead — the same transport-agnostic escape hatch
+ * `fly-entity-lookup` and `fly-people-picker` offer.
+ *
+ * Implements `ControlValueAccessor`, so it drops into reactive forms like `fly-select`. The
+ * value is the ISO 4217 **code** (`string | null` single, `string[]` multi) — never the row
+ * id, which belongs to whichever service served the list.
+ *
+ * ## Why every row shows a code, not just a flag
+ * Two independent reasons, both of which the picker must survive:
+ * 1. Windows renders flag emoji as two letters (no glyphs in Segoe UI Emoji). The component
+ *    measures this once and falls back to a styled code tile — deliberate-looking, not broken.
+ * 2. Four currencies (XAF/XOF/XPF/XCD) serve many countries and have NO representative flag,
+ *    so `flag` is legitimately null. Picking one member state's would be wrong, not imprecise.
+ *
+ * Search matches word-wise AND across code, name and symbol — the same semantics as the
+ * backend's `?search=`, so filtering client-side over the bounded catalogue cannot disagree
+ * with what a server-side filter would have returned.
+ *
+ * i18n is self-sufficient through the `currency_selector.*` keys in `DS_BASELINE_LOCALES`
+ * (en/ar/fr/ur); RTL works via logical CSS.
+ *
+ * @example
+ * ```html
+ * <!-- Loads /api/currencies/brief itself: -->
+ * <fly-currency-selector [(ngModel)]="invoiceCurrency" [pinnedCodes]="['AED','USD','EUR']" />
+ *
+ * <!-- Multi-select, restricted to what the tenant trades in: -->
+ * <fly-currency-selector
+ *   mode="multi"
+ *   [allowedCodes]="tenantCurrencies()"
+ *   (selectionDetailChange)="onCurrenciesPicked($event)" />
+ * ```
+ */
+declare class FlyCurrencySelectorComponent implements ControlValueAccessor {
+    private readonly http;
+    private readonly _i18n;
+    /** `'single'` (default) replaces the pick; `'multi'` accumulates chips. Set-once at compose time. */
+    readonly mode: _angular_core.InputSignal<FlyCurrencySelectorMode>;
+    /** Static rows — supply these to skip the fetch entirely (offline surfaces, fixtures). */
+    readonly currencies: _angular_core.InputSignal<readonly FlyCurrency[] | null>;
+    /** Host-supplied loader, used when `[currencies]` is absent. Falls back to `GET /api/currencies/brief`. */
+    readonly fetchFn: _angular_core.InputSignal<FlyCurrencyFetchFn | null>;
+    /** Restrict the offered set to these ISO 4217 codes (case-insensitive). Empty = offer everything. */
+    readonly allowedCodes: _angular_core.InputSignal<readonly string[]>;
+    /**
+     * Codes to surface in a "frequently used" group above the full list, in the order given.
+     * Deliberately empty by default: which currencies matter is the consuming app's business
+     * fact, and baking a house list into the design system would ship that opinion everywhere.
+     */
+    readonly pinnedCodes: _angular_core.InputSignal<readonly string[]>;
+    /** Disable the whole control (also driven by reactive-forms `setDisabledState`). */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Show the trigger clear (✕) affordance when there is a selection. */
+    readonly clearable: _angular_core.InputSignal<boolean>;
+    /** Trigger text when nothing is picked. Omit for the localized default. */
+    readonly placeholder: _angular_core.InputSignal<string | null>;
+    /** Placeholder for the in-panel search box. Omit for the localized default. */
+    readonly searchPlaceholder: _angular_core.InputSignal<string | null>;
+    /** Optional accessible name for the trigger (else the consumer's `<label for>` should reference it). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** The picked ISO 4217 codes, emitted after every pick / removal / clear. */
+    readonly selectionChange: _angular_core.OutputEmitterRef<readonly string[]>;
+    /** The picked rows in full — so a host formatting an amount has `symbol` + `decimalDigits` without re-resolving. */
+    readonly selectionDetailChange: _angular_core.OutputEmitterRef<readonly FlyCurrency[]>;
+    /** Emits when the panel opens (`true`) / closes (`false`). */
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly _uid;
+    readonly listboxId: string;
+    readonly triggerId: string;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly searchTerm: _angular_core.WritableSignal<string>;
+    readonly activeIndex: _angular_core.WritableSignal<number>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    /** True when flag emoji compose on this platform; false routes every tile to the code fallback. */
+    readonly flagsRenderable: _angular_core.WritableSignal<boolean>;
+    private readonly _loaded;
+    private readonly _selectedCodes;
+    private readonly _cvaDisabled;
+    private _fetchStarted;
+    private readonly searchEl?;
+    private readonly triggerEl?;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    readonly isMulti: _angular_core.Signal<boolean>;
+    readonly placeholderText: _angular_core.Signal<string>;
+    readonly searchPlaceholderText: _angular_core.Signal<string>;
+    readonly noResultsText: _angular_core.Signal<string>;
+    readonly loadingText: _angular_core.Signal<string>;
+    readonly errorText: _angular_core.Signal<string>;
+    readonly retryText: _angular_core.Signal<string>;
+    readonly clearText: _angular_core.Signal<string>;
+    readonly pinnedGroupText: _angular_core.Signal<string>;
+    readonly allGroupText: _angular_core.Signal<string>;
+    /** Every offered row, after the `allowedCodes` restriction. */
+    readonly available: _angular_core.Signal<readonly FlyCurrency[]>;
+    private readonly _byCode;
+    private readonly _selectedSet;
+    /** Picked rows in pick order. A code with no matching row yet (value set before the fetch landed) is skipped, not faked. */
+    readonly selected: _angular_core.Signal<readonly FlyCurrency[]>;
+    readonly hasSelection: _angular_core.Signal<boolean>;
+    /**
+     * Rows matching the search box. Word-wise AND over code / name / symbol — every
+     * whitespace-separated token must match something, in any order, which is the same
+     * contract `LookupQuery.ToLikePatterns` gives the backend's `?search=`.
+     */
+    readonly filtered: _angular_core.Signal<readonly FlyCurrency[]>;
+    /** The pinned rows, in the order the host listed them, minus anything the search filtered out. */
+    readonly pinned: _angular_core.Signal<readonly FlyCurrency[]>;
+    /** Everything not already shown in the pinned group. */
+    readonly rest: _angular_core.Signal<readonly FlyCurrency[]>;
+    /** Flat keyboard-navigation order — pinned group first, matching the render order. */
+    readonly navOptions: _angular_core.Signal<readonly FlyCurrency[]>;
+    optionId(index: number): string;
+    readonly activeDescendant: _angular_core.Signal<string>;
+    navIndexOf(code: string): number;
+    isSelected(code: string): boolean;
+    /**
+     * Two-letter tile shown when the platform can't compose flag emoji. ISO 4217 codes are
+     * built as "country code + currency initial" (AED = AE + Dirham), so the first two letters
+     * ARE the country for the overwhelming majority — a correct-by-construction fallback rather
+     * than an arbitrary truncation.
+     */
+    tileCode(currency: FlyCurrency): string;
+    toggleOpen(): void;
+    open(): void;
+    close(restoreFocus?: boolean): void;
+    pick(currency: FlyCurrency): void;
+    remove(code: string, event?: Event): void;
+    clear(event?: Event): void;
+    onTriggerKeydown(event: KeyboardEvent): void;
+    onPanelKeydown(event: KeyboardEvent): void;
+    onSearchInput(value: string): void;
+    onOptionHover(index: number): void;
+    retry(): void;
+    private _load;
+    writeValue(value: FlyCurrencySelectorValue): void;
+    registerOnChange(fn: (v: FlyCurrencySelectorValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** The form-control value: the single code (or null) in single mode, the code array in multi. */
+    private _controlValue;
+    private _commit;
+    private _touch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyCurrencySelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyCurrencySelectorComponent, "fly-currency-selector", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "currencies": { "alias": "currencies"; "required": false; "isSignal": true; }; "fetchFn": { "alias": "fetchFn"; "required": false; "isSignal": true; }; "allowedCodes": { "alias": "allowedCodes"; "required": false; "isSignal": true; }; "pinnedCodes": { "alias": "pinnedCodes"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "selectionDetailChange": "selectionDetailChange"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
 /**
  * Document-wide open-overlay stack — Escape arbitration for stacked overlays.
  *
@@ -8374,6 +9704,28 @@ type FlySearchInputSize = 'sm' | 'md' | 'lg';
  * is wrong half the time. The two-way `[(value)]` gives you the live text and
  * `(queryChange)` gives you the settled query, explicitly. Reactive-forms hosts wire
  * `(queryChange)` to `control.setValue(...)`.
+ *
+ * ## Nova morph (`collapsible`)
+ * `[collapsible]` renders the Nova SearchField morph — a circular magnifier that
+ * grows into a pill (D2 §3.1: 28×28 closed, `--fly-search-expanded-width` open,
+ * default 230px, `--nova-ease-structural` / `--nova-duration-settle`). Two extras
+ * beyond the geometry:
+ * - **Controlled or uncontrolled**, your choice — see {@link open}. Every existing
+ *   consumer is uncontrolled (the default) and is unaffected.
+ * - **A trailing slot** for composing something like the Home magic-bar's inline
+ *   Filters button, instead of hand-rolling the whole field per app:
+ *   ```html
+ *   <fly-search-input [collapsible]="true" [showFilterToggle]="false" ...>
+ *     <button flySearchTrailing type="button" (click)="openFilters()">Filters</button>
+ *   </fly-search-input>
+ *   ```
+ *   Rendered only while the field is expanded (never in the closed circle, so
+ *   projected content can't visibly break the morph geometry) and never while
+ *   `disabled`. It adds to the pill's content width same as the clear/filter
+ *   buttons do — widen `--fly-search-expanded-width` to fit it. This is a
+ *   SEPARATE mechanism from {@link showFilterToggle}'s built-in chevron; use
+ *   whichever fits — the chevron for the common toggle-a-panel case, this slot
+ *   when the affordance itself (icon, label, badge) needs to be bespoke.
  */
 declare class FlySearchInputComponent {
     private readonly i18n;
@@ -8438,6 +9790,30 @@ declare class FlySearchInputComponent {
     readonly showFilterToggle: _angular_core.InputSignal<boolean>;
     /** Reflects the host panel's open state — rotates the chevron and sets `aria-expanded`. */
     readonly filterPanelOpen: _angular_core.InputSignal<boolean>;
+    /**
+     * Controls a `collapsible` field's open/closed state from the OUTSIDE, the
+     * `open`/`onToggle` contract Nova's SearchField spec calls for (D2 §3.1).
+     * `null` (the default) means UNCONTROLLED — every existing consumer, which
+     * never passes this input — and the field keeps managing its own expand/
+     * collapse exactly as it always has (focus, hover, held value, filter panel).
+     *
+     * Passing `true`/`false` makes it CONTROLLED, the same "the host decides,
+     * this component only asks" shape {@link filterPanelOpen}/{@link
+     * filterToggled} already establish two properties up: the host binds `[open]`
+     * and listens on {@link expandedChange}, which doubles as `onToggle` while
+     * controlled (see its doc). Only consulted when {@link collapsible} is
+     * `true` — open/closed has no meaning for an always-open field.
+     *
+     * Why not a `model()` two-way signal like {@link value}: `isExpanded` here
+     * is normally the OUTPUT of several independent low-level signals (focus,
+     * hover, held value, filter-panel state), not one value the component owns
+     * outright — a `model()` would have to pick one of those to be "the" source
+     * of truth and the others would silently stop mattering. An `input` that
+     * simply overrides the rendered state when non-null, paired with the
+     * existing `expandedChange` intent signal, lets the low-level triggers
+     * keep working unchanged underneath in BOTH modes.
+     */
+    readonly open: _angular_core.InputSignal<boolean | null>;
     /**
      * The settled query — fires `debounceMs` after typing stops, and immediately on
      * clear.
@@ -8464,9 +9840,18 @@ declare class FlySearchInputComponent {
     /** Fires when the user clears the box (button or Escape). */
     readonly cleared: _angular_core.OutputEmitterRef<void>;
     /**
-     * Fires whenever a `collapsible` field expands (`true`) or collapses (`false`).
-     * Lets a host react to the reveal — e.g. yield sibling space to the growing
-     * field, or dim a title while the search is open.
+     * Fires whenever a `collapsible` field's internal gesture state (focus, hover,
+     * held value, filter panel) says it should expand (`true`) or collapse
+     * (`false`). Lets a host react to the reveal — e.g. yield sibling space to
+     * the growing field, or dim a title while the search is open.
+     *
+     * While {@link open} is bound (controlled mode), this is the `onToggle` half
+     * of the D2 §3.1 `open`/`onToggle` contract: it reports what the user's
+     * gesture WANTS, not the currently-rendered state (that stays pinned to
+     * whatever `open` says until the host reacts) — the same request/response
+     * shape {@link filterToggled} already uses for the filter panel. A host that
+     * doesn't bind `open` never notices the difference: with `open` unset the
+     * wanted state and the rendered state are the same value by construction.
      */
     readonly expandedChange: _angular_core.OutputEmitterRef<boolean>;
     /**
@@ -8486,9 +9871,23 @@ declare class FlySearchInputComponent {
     private readonly inputFocused;
     private readonly hovered;
     /**
-     * Whether a `collapsible` field is currently open. Non-collapsible fields are
-     * always "expanded". Open when: the field has focus, OR (hover trigger) it's
-     * hovered, OR it holds a query and {@link stayExpandedWithValue} is on.
+     * What the field's own low-level gesture signals want its open state to be:
+     * open when the field has focus, OR (hover trigger) it's hovered, OR it
+     * holds a query and {@link stayExpandedWithValue} is on, OR the filter panel
+     * is open (otherwise moving the pointer from the chevron to the panel
+     * collapses the field out from under the gesture, taking its own anchor
+     * with it). Non-collapsible fields always want "expanded".
+     *
+     * This is the UNCONTROLLED answer — see {@link isExpanded} for what actually
+     * renders, and {@link expandedChange} for how this reaches a controlled host.
+     */
+    private readonly desiredExpanded;
+    /**
+     * Whether a `collapsible` field is currently RENDERED open. Equals {@link
+     * desiredExpanded} unless a controlled {@link open} is bound, in which case
+     * the bound value wins outright — the host is the single source of truth,
+     * same as `[open]` on a controlled `<fly-drawer>`. Non-collapsible fields
+     * ignore `open` entirely (always "expanded"; open/closed has no meaning).
      */
     readonly isExpanded: _angular_core.Signal<boolean>;
     /** Collapsed + a pointer trigger ⇒ the whole control is the button that expands it. */
@@ -8517,7 +9916,7 @@ declare class FlySearchInputComponent {
     /** Moves focus into the input — for hosts wiring a `/` or Ctrl+F shortcut. */
     focus(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlySearchInputComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlySearchInputComponent, "fly-search-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; "debounceMs": { "alias": "debounceMs"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "expandTrigger": { "alias": "expandTrigger"; "required": false; "isSignal": true; }; "stayExpandedWithValue": { "alias": "stayExpandedWithValue"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showFilterToggle": { "alias": "showFilterToggle"; "required": false; "isSignal": true; }; "filterPanelOpen": { "alias": "filterPanelOpen"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "queryChange": "queryChange"; "searched": "searched"; "submitted": "submitted"; "cleared": "cleared"; "expandedChange": "expandedChange"; "filterToggled": "filterToggled"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlySearchInputComponent, "fly-search-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; "debounceMs": { "alias": "debounceMs"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "expandTrigger": { "alias": "expandTrigger"; "required": false; "isSignal": true; }; "stayExpandedWithValue": { "alias": "stayExpandedWithValue"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showFilterToggle": { "alias": "showFilterToggle"; "required": false; "isSignal": true; }; "filterPanelOpen": { "alias": "filterPanelOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "queryChange": "queryChange"; "searched": "searched"; "submitted": "submitted"; "cleared": "cleared"; "expandedChange": "expandedChange"; "filterToggled": "filterToggled"; }, never, ["[flySearchTrailing]"], true, never>;
 }
 
 /**
@@ -9114,6 +10513,14 @@ declare function resolveStateMessageKey(kind: StateMessageKind, override?: strin
  * Empty / loading / error / success / warning page state.
  * Source visual: the legacy `.circles-state-message` block (+ `--error`
  * modifier). Extra CTAs project into the default slot.
+ *
+ * `kind="empty"` renders the D2 §3.3 EmptyState anatomy (UX-refresh S1.9): a
+ * 46px icon TILE (radius 16, `var(--w07)` fill, `var(--w12)` border) instead
+ * of a bare washed-out glyph, `messageKey` promoted to a bold title, and an
+ * optional `noteKey` for the lighter description line underneath. `noteKey`
+ * is additive — omitting it renders exactly the single-line empty state that
+ * shipped before this task, just inside the new icon tile. Every other kind
+ * (`loading`/`error`/`success`/`warning`) is visually unchanged.
  */
 declare class FlyStateMessageComponent {
     readonly kind: _angular_core.InputSignal<StateMessageKind>;
@@ -9121,6 +10528,8 @@ declare class FlyStateMessageComponent {
     readonly messageKey: _angular_core.InputSignal<string | undefined>;
     /** `pi-*` class override, e.g. `pi-bolt`. */
     readonly iconClass: _angular_core.InputSignal<string | undefined>;
+    /** Lighter description line under the title — `kind="empty"` only. Omit for the single-line empty state. */
+    readonly noteKey: _angular_core.InputSignal<string | undefined>;
     readonly retryLabelKey: _angular_core.InputSignal<string>;
     /** Renders the retry button (kind=error only). */
     readonly showRetry: _angular_core.InputSignal<boolean>;
@@ -9128,7 +10537,7 @@ declare class FlyStateMessageComponent {
     protected readonly icon: _angular_core.Signal<string>;
     protected readonly resolvedMessageKey: _angular_core.Signal<string | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyStateMessageComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyStateMessageComponent, "fly-state-message", never, { "kind": { "alias": "kind"; "required": false; "isSignal": true; }; "messageKey": { "alias": "messageKey"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; "retryLabelKey": { "alias": "retryLabelKey"; "required": false; "isSignal": true; }; "showRetry": { "alias": "showRetry"; "required": false; "isSignal": true; }; }, { "retried": "retried"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyStateMessageComponent, "fly-state-message", never, { "kind": { "alias": "kind"; "required": false; "isSignal": true; }; "messageKey": { "alias": "messageKey"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; "noteKey": { "alias": "noteKey"; "required": false; "isSignal": true; }; "retryLabelKey": { "alias": "retryLabelKey"; "required": false; "isSignal": true; }; "showRetry": { "alias": "showRetry"; "required": false; "isSignal": true; }; }, { "retried": "retried"; }, never, ["*"], true, never>;
 }
 
 /** Inline busy indicator — spinner glyph plus optional label. */
@@ -9165,6 +10574,17 @@ declare class FlyActionStackComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyActionStackComponent, "fly-action-stack", never, { "triggerVariant": { "alias": "triggerVariant"; "required": false; "isSignal": true; }; "triggerTooltipKey": { "alias": "triggerTooltipKey"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
+/**
+ * As of UX-refresh S1.9, `status` also recognizes the D2 §5 priority
+ * vocabulary (`critical`/`urgent`/`high`/`normal`/`low`), coloured from the
+ * same shared Nova tone map as the five ratified status values
+ * (`published`/`review`/`approved`/`draft`/`archived` — `nova-status-tone()`
+ * / `nova-priority-tone()` in `app-surface/styles/_mixins.scss`). This is
+ * additive to the existing 10-value workflow-status set, not a new input:
+ * apps pass a priority the exact same way they already pass a status —
+ * `[status]="item.priority"` — and must have a matching `common.status.
+ * <value>` locale entry, same as today.
+ */
 declare class StatusBadgeComponent {
     status: _angular_core.InputSignal<string>;
     /** Render as a colour-coded "status light" dot with the label on hover/SR
@@ -9178,6 +10598,62 @@ declare class StatusBadgeComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusBadgeComponent, "fly-status-badge", never, { "status": { "alias": "status"; "required": true; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "domain": { "alias": "domain"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * TypeScript mirror of the Sass `nova-priority-tone()` / `nova-status-tone()`
+ * functions in `app-surface/styles/_mixins.scss`.
+ *
+ * The kit owns this map ONCE (UX-refresh S1.9 — see the Sass file's own
+ * comment for the full RAD justification: 20 Stage-4 apps would otherwise each
+ * re-derive "Critical → red, Urgent/High → orange…"). It is authored twice —
+ * once as a Sass function for a component's own compile-time literal classes
+ * (`.status-badge--critical { color: ui.nova-priority-tone('critical'); }`),
+ * once here as a plain object — because a Sass `@function` cannot be called
+ * from an Angular template. Anything binding a colour off a RUNTIME value
+ * (page data, not a fixed template literal — e.g. `[style.color]` on a
+ * hand-composed leading status dot) reads this map instead.
+ *
+ * Values are CSS custom-property NAMES (no `var()` wrapper), so a caller binds
+ * them through Angular:
+ *
+ * ```html
+ * <span [style.color]="'var(' + novaPriorityToneVar(item.priority) + ')'"></span>
+ * ```
+ *
+ * Bind with `[style.color]` — never interpolate into a literal `style="…"`
+ * attribute. A static `style` attribute containing `{{ }}` is not a binding at
+ * all: Angular emits it as an inline style, which the platform's strict CSP
+ * (`style-src 'self' 'nonce-…'`) blocks outright, and the failure surfaces as a
+ * silently uncoloured dot plus a console entry naming a sha256 nobody can trace
+ * back to here. `[style.color]` is set via the CSSOM and is unaffected.
+ *
+ * Keep this in sync with `_mixins.scss`'s two functions — `nova-tone.spec.ts`
+ * pins both maps' key/value pairs so a drift between the Sass and TS copies
+ * fails a test instead of shipping a colour mismatch between a component's own
+ * CSS classes and a page's hand-bound dot.
+ */
+/** D2 §5 priority map. Keys are lower-case; unknown keys resolve via {@link novaPriorityToneVar}'s fallback. */
+declare const NOVA_PRIORITY_TONE: Readonly<Record<string, string>>;
+/**
+ * D2 §5 status map. `under-review` is the canonical key; `review` is accepted
+ * as a synonym — it is the shorter key `fly-status-badge`'s pre-existing
+ * status vocabulary already shipped for the same real-world state.
+ */
+declare const NOVA_STATUS_TONE: Readonly<Record<string, string>>;
+/** The ramp's own "meta / neutral" step — the fallback for a key neither map recognizes. */
+declare const NOVA_TONE_FALLBACK = "--w42";
+/**
+ * Resolves a priority string to a Nova custom-property NAME (e.g. `--sys-red`),
+ * case-insensitive.
+ *
+ * Accepts nullish. A status/priority field is routinely optional in the domain
+ * models these badges render, so `undefined` reaching here is ordinary data,
+ * not a caller bug — and the signature freezes at 1.8.0, where widening it later
+ * would be a MAJOR. Nullish resolves to the same neutral step as an unknown key.
+ */
+declare function novaPriorityToneVar(priority: string | null | undefined): string;
+/** Resolves a status string to a Nova custom-property NAME (e.g. `--sys-green`), case-insensitive. Accepts nullish — see {@link novaPriorityToneVar}. */
+declare function novaStatusToneVar(status: string | null | undefined): string;
+
 declare class DashboardKpiComponent {
     label: _angular_core.InputSignal<string>;
     value: _angular_core.InputSignal<string | number>;
@@ -9208,7 +10684,7 @@ interface FlyMetaItem {
  * global `.mono` utility for the small monospace value treatment.
  */
 declare class FlyMetaListComponent {
-    readonly items: _angular_core.InputSignal<FlyMetaItem[]>;
+    readonly items: _angular_core.InputSignal<readonly FlyMetaItem[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyMetaListComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyMetaListComponent, "fly-meta", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -9221,6 +10697,19 @@ declare class FlyMetaListComponent {
  *
  *   <fly-pagination [page]="page()" [totalPages]="totalPages()"
  *                   [rangeText]="rangeText()" (pageChange)="goToPage($event)" />
+ *
+ * Restyled to the D2 §5 pagination canon (UX-refresh S1.9): prev/next are 26px
+ * circular arrow buttons (an SVG chevron replaces the old text label; the
+ * label survives as the button's `aria-label`, already wired) and the current
+ * indicator is a solid-accent pill with tabular numerals. D2 describes a row
+ * of numbered "page dots" for the reference signals-list pager — this kit
+ * deliberately keeps the existing prev/current/next SHAPE rather than adding a
+ * numbered-page-range renderer (a new page-window/ellipsis computation, not a
+ * restyle) and applies the same visual language — 26px circular arrows, a
+ * 24px-tall accent-filled current indicator, tabular-nums — to it instead; see
+ * `.workflow/plans/ux-refresh/notes/S1.9-content-primitives.md` for the full
+ * reasoning. `data-arrow` on the prev/next glyphs mirrors under RTL exactly
+ * like the existing first/last chevrons.
  */
 declare class FlyPaginationComponent {
     readonly page: _angular_core.InputSignal<number>;
@@ -9244,6 +10733,17 @@ declare function canGoNext(page: number, totalPages: number): boolean;
 declare function clampPage(page: number, totalPages: number): number;
 
 type CardLayout = 'row' | 'column';
+/**
+ * Row-layout density (UX-refresh S1.9, D2 §5). `roomy` (default) is today's
+ * anatomy unchanged. `compact` is the real behaviour the design calls for when
+ * a detail pane opens beside the list — NOT a size token: the title drops to
+ * 12.5px and `fly-card-status` is hidden (the design moves status INTO the
+ * meta strip in compact mode; since the card has no way to know which
+ * projected meta chip IS the status, the app renders that chip itself — see
+ * COMPONENTS.md). Column layout ignores this input; it has its own fixed
+ * density.
+ */
+type CardDensity = 'roomy' | 'compact';
 /**
  * Listing card shell — one anatomy for the three reference card patterns:
  *
@@ -9273,9 +10773,20 @@ type CardLayout = 'row' | 'column';
  * Hover: the default interactive hover darkens the hairline and keeps the
  * resting shadow (cluster/trend source); `lift` opts into the
  * translateY/`--shadow-filter` raise for pages that want it.
+ *
+ * Row-layout visual canon (D2 §5, UX-refresh S1.9): a plain (non-selectable)
+ * row rests transparent and tints `var(--w04)` on hover, separated from its
+ * siblings by a 1px `var(--w07)` hairline rendered as a host pseudo-element —
+ * NOT a border, so it disappears under `[selectable]`'s card treatment
+ * (bordered `var(--w07)`/`var(--w04)`, selected → `var(--accent)`/
+ * `var(--tint-sel)`, hover → `var(--w06)`/`var(--w14)`) without a seam. Rows
+ * animate in with `itemIn`, staggered 40ms; column cards use `riseIn`,
+ * staggered 55ms (skill §5's item/card stagger split).
  */
 declare class FlyCardComponent {
     readonly layout: _angular_core.InputSignal<CardLayout>;
+    /** Row-layout density (`roomy` default / `compact`) — ignored in column layout. */
+    readonly density: _angular_core.InputSignal<CardDensity>;
     /** Renders the hover/focus-revealed selection checkbox — row layout only. */
     readonly selectable: _angular_core.InputSignal<boolean>;
     readonly selected: _angular_core.ModelSignal<boolean>;
@@ -9304,7 +10815,7 @@ declare class FlyCardComponent {
      */
     protected onKey(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyCardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyCardComponent, "fly-card", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lift": { "alias": "lift"; "required": false; "isSignal": true; }; "selectLabelKey": { "alias": "selectLabelKey"; "required": false; "isSignal": true; }; "selectLabel": { "alias": "selectLabel"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "activated": "activated"; }, never, ["fly-card-media", "fly-card-title", "*", "fly-card-body", "fly-card-meta", "fly-card-status", "fly-card-footer", "fly-card-actions"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyCardComponent, "fly-card", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lift": { "alias": "lift"; "required": false; "isSignal": true; }; "selectLabelKey": { "alias": "selectLabelKey"; "required": false; "isSignal": true; }; "selectLabel": { "alias": "selectLabel"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "activated": "activated"; }, never, ["fly-card-media", "fly-card-title", "*", "fly-card-body", "fly-card-meta", "fly-card-status", "fly-card-footer", "fly-card-actions"], true, never>;
 }
 
 /**
@@ -10071,6 +11582,7 @@ declare function initialExpanded(sections: readonly Pick<FlyAppModuleSection, 'c
  */
 declare function sectionHintKey(section: Pick<FlyAppModuleSection, 'collapsible' | 'hintKey' | 'collapsedHintKey'>, expanded: boolean): string | null;
 
+type TabsVariant = 'underline' | 'segmented';
 /**
  * Underline tab row + panels — visual port of the signal-detail sidecard tab
  * row (`.llc__tabs` / `.llc__tab`); also replaces the job-profile
@@ -10085,6 +11597,14 @@ declare function sectionHintKey(section: Pick<FlyAppModuleSection, 'collapsible'
  * </fly-tabs>
  * ```
  *
+ * `variant="segmented"` (UX-refresh S1.9, D2 §1.3) renders the OTHER tab
+ * anatomy the source design uses for its detail-page tab strips (Metadata /
+ * Evidence / Linked trends / … and Tasks' 3-tab row): a pill-shaped
+ * `role="tablist"` track with the active tab as a raised pill inside it,
+ * instead of an underline baseline. Same component, same a11y wiring, same
+ * `fly-tab` children — only the CSS skin switches; `underline` (default)
+ * keeps every existing consumer pixel-identical.
+ *
  * a11y: `role="tablist"`/`tab`/`tabpanel` with `aria-selected`/`aria-controls`
  * wiring, roving tabindex (active tab is the tab stop), RTL-aware arrow-key
  * navigation with wrap-around and Home/End; arrows move both selection and
@@ -10099,6 +11619,8 @@ declare class FlyTabsComponent {
     readonly selected: _angular_core.ModelSignal<string | undefined>;
     /** Group label for the tablist. */
     readonly ariaLabelKey: _angular_core.InputSignal<string | undefined>;
+    /** Tab-strip skin — `underline` (default, unchanged) or `segmented` (D2 §1.3 pill track). */
+    readonly variant: _angular_core.InputSignal<TabsVariant>;
     protected readonly tabItems: _angular_core.Signal<readonly any[]>;
     readonly activeId: _angular_core.Signal<string | null>;
     tabId(id: string): string;
@@ -10106,7 +11628,7 @@ declare class FlyTabsComponent {
     protected select(id: string): void;
     protected onKey(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlyTabsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyTabsComponent, "fly-tabs", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["tabItems"], ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlyTabsComponent, "fly-tabs", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["tabItems"], ["*"], true, never>;
 }
 /**
  * One tab of a `fly-tabs` group: declares the tab button (id, label, optional
@@ -10270,7 +11792,7 @@ declare function nextSegmentIndex(current: number, key: string, length: number,
 declare class FlySegmentedComponent {
     private readonly i18n;
     private readonly el;
-    readonly options: _angular_core.InputSignal<SegmentedOption[]>;
+    readonly options: _angular_core.InputSignal<readonly SegmentedOption[]>;
     readonly value: _angular_core.ModelSignal<string | undefined>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly ariaLabelKey: _angular_core.InputSignal<string | undefined>;
@@ -10338,9 +11860,11 @@ declare class FlySliderComponent {
 declare function clampSliderValue(value: number, min: number, max: number): number;
 /**
  * Gradient fill for the range track (the legacy confidence-slider
- * `--rng-track`): brand teal→purple up to the value, rest neutral. All colour
- * stops resolve through tokens so themes restyle the track. Mirrored under RTL
- * (native range inputs flip, `to right` would not).
+ * `--rng-track`): D2 §1.3's confidence-meter recipe, `linear-gradient(90deg, var(--accent),
+ * var(--sys-teal))` — this slider IS that confidence control (the class docblock names it as the
+ * port), so the fill up to the value runs accent→teal, the rest sits at the Nova input-border
+ * tier (`--w14`). All colour stops resolve through tokens so themes restyle the track. Mirrored
+ * under RTL (native range inputs flip, `to right` would not).
  */
 declare function sliderTrackGradient(value: number, min: number, max: number, rtl: boolean): string;
 
@@ -10628,7 +12152,7 @@ declare function nextEnabledIndex(items: readonly ActionMenuItem[], current: num
 declare class FlyActionMenuComponent {
     private readonly el;
     private readonly injector;
-    readonly items: _angular_core.InputSignal<ActionMenuItem[]>;
+    readonly items: _angular_core.InputSignal<readonly ActionMenuItem[]>;
     readonly triggerTooltipKey: _angular_core.InputSignal<string>;
     /** Id of the activated item. */
     readonly selected: _angular_core.OutputEmitterRef<string>;
@@ -10736,6 +12260,6 @@ declare const AUDIENCE_ERROR_CODES: {
 };
 type AudienceErrorCode = (typeof AUDIENCE_ERROR_CODES)[keyof typeof AUDIENCE_ERROR_CODES];
 
-export { AGENT_DRAG_MIME, AGENT_PAYLOAD_VERSION, APP_LOOKUP, AUDIENCE_ERROR_CODES, AUDIENCE_LIMITS, AUDIENCE_PRESETS, AUDIENCE_TERM_KINDS, AgentActionBus, AgentActionUnsupportedDispatchError, AgentCommandRegistry, AgentDropRegistry, AgentFlightAnimator, AgentLookupRegistry, AgentPayloadOversizeError, AudienceBuilderComponent, AuthService, BilingualFieldComponent, CRON_MODES, CRON_WEEKDAYS, ContextMenuComponent, DEFAULT_AGENT_PAYLOAD_LIMITS, DEFAULT_FLY_THEME_MODE, DS_BASELINE_LOCALES, DashboardKpiComponent, DialogResult, EntityLookupComponent, FLYOS_LAUNCH_EVENT, FLYOS_LAUNCH_REQUEST_EVENT, FLYOS_REMOTE_ROUTE_EVENT, FLY_ACCENT_PROPERTY, FLY_ADMIN_ROLES, FLY_CHUNK_RELOAD_FLAG, FLY_COMPACT_THRESHOLD, FLY_COUNTRIES, FLY_EMOJI_BY_ID, FLY_EMOJI_CATEGORIES, FLY_EMOJI_CATEGORY_BY_ID, FLY_EMOJI_DEFAULT_CATEGORIES, FLY_EMOJI_PACK, FLY_EMOJI_PACK_MISSING_MESSAGE, FLY_EMOJI_PREVIEW_COUNT, FLY_EMPTY_VALUE, FLY_LOCALE_CATALOG, FLY_NF_CACHE_HEAL_FLAG, FLY_RELOAD_DEBOUNCE_MS, FLY_RELOAD_REARM_MS, FLY_REMOTE_BASE_PATH, FLY_REMOTE_CONTEXT_EVENT, FLY_REMOTE_CONTEXT_STORE_KEY, FLY_REMOTE_ROUTES, FLY_SCAN_PENDING_DEFAULT_DELAY_MS, FLY_SCAN_PENDING_MAX_RETRIES, FLY_SCAN_PENDING_STATUS, FLY_SEARCH_DEBOUNCE_MS, FLY_SKIN_TONES, FLY_STANDALONE_AUTH_CONFIG, FLY_THEME_MODE_IDS, FLY_WINDOW_HELP_HINT_EVENT, FLY_WINDOW_PAGE_TITLE_EVENT, FlyAchievementProgressComponent, FlyActionMenuComponent, FlyActionStackComponent, FlyAgentDraggableDirective, FlyAnimatedEmojiComponent, FlyAppHomeComponent, FlyAppTopbarComponent, FlyAuthLiveRefresh, FlyBadgeWallComponent, FlyBlockUiComponent, FlyBreadcrumbComponent, FlyButtonComponent, FlyBytesPipe, FlyCaptchaComponent, FlyCardActionsComponent, FlyCardBodyComponent, FlyCardComponent, FlyCardFooterComponent, FlyCardGridComponent, FlyCardMediaComponent, FlyCardMetaComponent, FlyCardStatusComponent, FlyCardTitleComponent, FlyCellDirective, FlyCheckboxComponent, FlyChipComponent, FlyChunkReloadErrorHandler, FlyClickOutsideDirective, FlyCollapsibleComponent, FlyCommentThreadComponent, FlyCompactNumberPipe, FlyConfirmDialogComponent, FlyControlDirective, FlyCronBuilderComponent, FlyDataTableComponent, FlyDatePipe, FlyDateTimePipe, FlyDebouncer, FlyDecimalNumberPipe, FlyDetailCardComponent, FlyDetailShellComponent, FlyDrawerComponent, FlyDurationPipe, FlyDynamicFormComponent, FlyEmojiPickerComponent, FlyFieldComponent, FlyFileDownloadService, FlyFileUploadComponent, FlyFilterPanelComponent, FlyFormBannerComponent, FlyFormFooterComponent, FlyFormGridComponent, FlyFormSectionComponent, FlyFullNumberPipe, FlyGanttComponent, FlyHubClient, FlyIconButtonComponent, FlyIfAdminDirective, FlyIfRoleDirective, FlyImageUploadComponent, FlyLeaderboardComponent, FlyMetaListComponent, FlyModalComponent, FlyModerationQueueComponent, FlyModuleIconDirective, FlyPaginationComponent, FlyPeoplePickerComponent, FlyPointsTierComponent, FlyProgressComponent, FlyRelativeTimePipe, FlyRemoteContextService, FlyRemoteRouter, FlyRemoteRouterOutletComponent, FlySearchInputComponent, FlySectionHeaderComponent, FlySecureSrcDirective, FlySegmentedComponent, FlySelectComponent, FlySkeletonComponent, FlySliderComponent, FlySparklineComponent, FlySpinnerComponent, FlyStandaloneAuthCallbackComponent, FlyStandaloneAuthService, FlyStateMessageComponent, FlyDynamicFormComponent as FlySurveyFormComponent, FlyTabComponent, FlyTabsComponent, FlyTagsInputComponent, FlyThemeService, FlyTimePipe, FlyToastService, FlyToggleComponent, FlyTooltipDirective, FlyTreeNavComponent, FlyTypeaheadComponent, FlyUserDirectoryService, FlyWindowHelpService, FlyWindowTitleService, FlyosPendingLaunchesGlobalKey, FlyosShellHandlesLaunchRequestsGlobalKey, FlyosShellOwnsHistoryGlobalKey, GANTT_ZOOMS, I18nService, LAUNCH_CONTEXT, MessageBoxButtons, MessageBoxComponent, MessageBoxIcon, MessageBoxService, MockAuthService, OverlayStack, PRESENCE_COLORS, PageHeaderComponent, RTL_LOCALE_SET, SHARE_ORG_CHART_SYSTEM_KEY_APPS, SHARE_ORG_CHART_SYSTEM_KEY_DEFAULT, SHARE_PANEL_DEFAULT_FILE_LEVELS, STATE_DEFAULT_ICONS, STATE_DEFAULT_MESSAGE_KEYS, STEP_UP_CODE, STEP_UP_REAUTH_HANDLER, STEP_UP_RETURN_KEY, SUPPORTED_AGENT_PAYLOAD_VERSIONS, SharePanelComponent, SourceAppResolver, StandaloneWindowManagerService, StatusBadgeComponent, StepUpService, ToastHostComponent, TranslatePipe, WINDOW_DATA, WINDOW_HELP_HINT, WindowManagerService, applySkinTone, applySuggestion, ariaSort, buildCron, canConfirm, canGoNext, canGoPrev, captureFocus, clampPage, clampSliderValue, connectRemoteLaunch, enterActivatesNatively, filterGroup, filterSuggestions, findLocaleByDialect, findLocaleByPrefix, firstEnabledIndex, firstModuleIndex, flattenModules, flyAdminGuard, flyApiErrorMessage, flyCaptchaBase64Utf8, flyCaptchaBuildToken, flyCaptchaSha256Hex, flyCompactNumber, flyDebounced, flyDecimalNumber, flyDownloadBlob, flyDuration, flyEmojiFor, flyEmojiIsTonable, flyEmojiPackUrl, flyExportFileName, flyFirstEnabledIndex, flyFormatBytes, flyFormatDate, flyFormatDateTime, flyFormatTime, flyFullNumber, flyNextEnabledIndex, flyNextSegmentIndex, flyRelativeTime, flyResolveActiveTab, flyRoleGuard, flyScanPendingDelayMs, flyScanRetry, flySignedCompact, flySkinToneLabelKey, flyStandaloneAuthGuard, flyStandaloneAuthInterceptor, flyToDateOnly, flyToPage, flyUnwrap, flyUnwrapLenient, hasAnyRoleIn, healNativeFederationCacheOnce, initialExpanded, isAccentColor, isChunkLoadError, isFlyAuthStorePopulated, isNativeFederationCacheError, isRtlLocale, isRtlLocaleEntry, isValidCron, isValidSingleField, loadRemoteStyles, matchFlyRoutePattern, nextEnabledIndex, nextModuleIndex, nextSegmentIndex, nextSort, normalizeFlyTheme, normalizeRoles, overlayStack, parseCron, parseStepUpChallenge, parseTags, presenceColorFor, printConsoleSecurityWarning, provideFlyChunkReloadRecovery, provideFlyEmojiPack, provideFlyStandaloneAuth, reloadOnceForChunkError, requestAppLaunch, resolveActiveModule, resolveActiveSection, resolveActiveTab, resolveCellValue, resolveStateIcon, resolveStateMessageKey, restoreFocus, sameTags, sectionHintKey, sectionLayout, sliderTrackGradient, sparklinePath, sparklinePoints, stepUpInterceptor, stepUpReturnKey, trimAgentPayload, trimAgentString, unloadRemoteStyles, utf8ByteLength, validateAgentPayload, warnIfEmbeddedSessionMissing };
-export type { ActionMenuItem, AgentAction, AgentActionDispatch, AgentActionVerb, AgentChipHostInputs, AgentCommand, AgentCommandContextBinding, AgentCommandHandle, AgentCommandRegistration, AgentCommandScope, AgentCommandSlashSpec, AgentDragPayload, AgentDraggableItem, AgentDropChipMode, AgentDropRendererRegistration, AgentEnvelopeAttachment, AgentMcpScope, AgentMessageEnvelope, AgentPayloadLimits, AgentPayloadValidationResult, AppEveryonePrincipal, AppEveryoneTerm, AppLookup, AppLookupEntry, AudienceEditTarget, AudienceErrorCode, AudienceFilter, AudienceOptions, AudiencePresetKind, AudienceTerm, AudienceTermKind, BreadcrumbItem, ButtonSize, ButtonVariant, CardLayout, ChartTerm, ChildWindowData, ChipTone, ConfirmKind, ConnectRemoteLaunchOptions, ContextMenuAlign, ContextMenuItem, ContextMenuSection, CronAdvancedFieldDef, CronMode, CronParts, CronWeekday, DesktopApp, DesktopAppCategory, DesktopAppKind, DetailSection, DialogResultWithAcknowledgement, EmbeddedSessionProbe, EntityLinkSelection, FilterGroup, FlyAchievementRow, FlyApiError, FlyApiResponse, FlyAppHomeLayout, FlyAppModule, FlyAppModuleSection, FlyAuthRefreshPayload, FlyAuthStoreReadable, FlyBadgeTile, FlyBreadcrumbItem, FlyCaptchaChallenge, FlyCaptchaSolution, FlyCaptchaState, FlyCellContext, FlyColumn, FlyColumnKind, FlyComment, FlyCommentDeleteRequest, FlyCommentEditRequest, FlyCommentLoadMoreRequest, FlyCommentLoadRepliesRequest, FlyCommentLockToggleRequest, FlyCommentPage, FlyCommentReportReason, FlyCommentReportRequest, FlyCommentReportStatus, FlyCommentSubmitRequest, FlyCountry, FlyDrawerSide, FlyDrawerSize, FlyEmojiCategory, FlyEmojiCell, FlyEmojiEntry, FlyEmojiPack, FlyEmojiPackEntry, FlyEmojiPackManifest, FlyEmojiPickerSize, FlyEmojiPickerTab, FlyEmojiSection, FlyFileInfo, FlyFileSelection, FlyFormAnswer, FlyFormAnswerValue, FlyFormDefinition, FlyFormFieldOptions, FlyFormOption, FlyFormQuestion, FlyFormQuestionType, FlyFormScoreDisplay, FlyLaunchEventDetail, FlyLaunchRequestDetail, FlyLeaderboardRow, FlyLiveRefreshOptions, FlyLocaleEntry, FlyMetaItem, FlyModerationLoadPageRequest, FlyModerationLockThreadRequest, FlyModerationOpenSubjectRequest, FlyModerationReport, FlyModerationReportPage, FlyModerationResolutionStatus, FlyModerationResolveRequest, FlyNavigableItem, FlyPageMeta, FlyPageResult, FlyPaged, FlyPeoplePickerMode, FlyPeoplePickerOption, FlyPeopleSearchFn, FlyPointsSummary, FlyRemoteContext, FlyRemoteEagerRoute, FlyRemoteLazyRoute, FlyRemoteLoadedComponent, FlyRemoteMatch, FlyRemoteRoute, FlyRemoteRouteEventDetail, FlySearchExpandTrigger, FlySearchInputSize, FlySecureSrcState, FlySelectOption, FlySelectValue, FlySkeletonAnimation, FlySkeletonLayout, FlySkeletonShape, FlySkinTone, FlySort, FlyStandaloneAuthConfig, FlyFileSelection as FlySurveyFileSelection, FlyFormAnswer as FlySurveyFormAnswer, FlyFormAnswerValue as FlySurveyFormAnswerValue, FlyFormDefinition as FlySurveyFormDefinition, FlyFormFieldOptions as FlySurveyFormFieldOptions, FlyFormOption as FlySurveyFormOption, FlyFormQuestion as FlySurveyFormQuestion, FlyFormQuestionType as FlySurveyQuestionType, FlyThemeMode, FlyTooltipPlacement, FlyTreeNavNode, FlyTypeaheadOption, FlyWindowHelpHintEventDetail, FlyWindowHelpPublisher, FlyWindowPageTitleEventDetail, FlyWindowTitlePublisher, FlyosPendingLaunches, FocusRestore, FormBannerKind, GanttDependency, GanttDependencyCreate, GanttRow, GanttRowDatesChange, GanttRowKind, GanttZoom, IconButtonVariant, LaunchContext, LoadBundleOptions, LookupDescriptor, LookupHandle, LookupRegistration, LookupResult, LookupSearch, MessageBoxButton, MessageBoxDontAskAgainConfig, MessageBoxOptions, MessageBoxOptionsWithAcknowledgement, MockAuthConfig, OpenWindowOptions, OuPrincipal, OuTerm, OverlayHandle, PageHeaderVariant, PresetTerm, ProgressTone, RemoteAppDef, RequestAppLaunchOptions, RoleOuLookupRow, RolePrincipal, RolesTerm, SegmentedOption, ShareOrgChartOption, ShareOuNode, SharePanelLevelOption, SharePermissionEntry, SharePrincipal, SharePrincipalKind, ShareUserResult, StateMessageKind, StepUpChallenge, StepUpReauthHandler, StepUpReauthRequest, ToastAction, ToastEntry, ToastOptions, ToastVariant, User, UserPrincipal, UsersTerm, WindowHelpHint, WindowInstance, WindowState };
+export { AGENT_DRAG_MIME, AGENT_PAYLOAD_VERSION, APP_LOOKUP, AUDIENCE_ERROR_CODES, AUDIENCE_LIMITS, AUDIENCE_PRESETS, AUDIENCE_TERM_KINDS, AgentActionBus, AgentActionUnsupportedDispatchError, AgentCommandRegistry, AgentDropRegistry, AgentFlightAnimator, AgentLookupRegistry, AgentPayloadOversizeError, AudienceBuilderComponent, AuthService, BilingualFieldComponent, CRON_MODES, CRON_WEEKDAYS, ContextMenuComponent, DEFAULT_AGENT_PAYLOAD_LIMITS, DEFAULT_FLY_THEME_MODE, DS_BASELINE_LOCALES, DashboardKpiComponent, DialogResult, EntityLookupComponent, FLYOS_LAUNCH_EVENT, FLYOS_LAUNCH_REQUEST_EVENT, FLYOS_REMOTE_ROUTE_EVENT, FLY_ACCENT_PROPERTY, FLY_ADMIN_ROLES, FLY_CHUNK_RELOAD_FLAG, FLY_COMPACT_THRESHOLD, FLY_COUNTRIES, FLY_EMOJI_BY_ID, FLY_EMOJI_CATEGORIES, FLY_EMOJI_CATEGORY_BY_ID, FLY_EMOJI_DEFAULT_CATEGORIES, FLY_EMOJI_PACK, FLY_EMOJI_PACK_MISSING_MESSAGE, FLY_EMOJI_PREVIEW_COUNT, FLY_EMPTY_VALUE, FLY_LOCALE_CATALOG, FLY_MAGIC_BAR_EVENT, FLY_MAGIC_BAR_ICONS, FLY_MAGIC_BAR_STORE_KEY, FLY_NF_CACHE_HEAL_FLAG, FLY_RELOAD_DEBOUNCE_MS, FLY_RELOAD_REARM_MS, FLY_REMOTE_BASE_PATH, FLY_REMOTE_CONTEXT_EVENT, FLY_REMOTE_CONTEXT_STORE_KEY, FLY_REMOTE_ROUTES, FLY_SCAN_PENDING_DEFAULT_DELAY_MS, FLY_SCAN_PENDING_MAX_RETRIES, FLY_SCAN_PENDING_STATUS, FLY_SEARCH_DEBOUNCE_MS, FLY_SKIN_TONES, FLY_STANDALONE_AUTH_CONFIG, FLY_THEME_MODE_IDS, FLY_WINDOW_HELP_HINT_EVENT, FLY_WINDOW_PAGE_TITLE_EVENT, FlyAchievementProgressComponent, FlyActionMenuComponent, FlyActionStackComponent, FlyAgentDraggableDirective, FlyAnimatedEmojiComponent, FlyAppHomeComponent, FlyAppTopbarComponent, FlyAuthLiveRefresh, FlyBadgeWallComponent, FlyBlockUiComponent, FlyBreadcrumbComponent, FlyButtonComponent, FlyBytesPipe, FlyCaptchaComponent, FlyCardActionsComponent, FlyCardBodyComponent, FlyCardComponent, FlyCardFooterComponent, FlyCardGridComponent, FlyCardMediaComponent, FlyCardMetaComponent, FlyCardStatusComponent, FlyCardTitleComponent, FlyCellDirective, FlyCheckboxComponent, FlyChipComponent, FlyChunkReloadErrorHandler, FlyClickOutsideDirective, FlyCollapsibleComponent, FlyCommentThreadComponent, FlyCompactNumberPipe, FlyConfirmDialogComponent, FlyControlDirective, FlyCronBuilderComponent, FlyCurrencySelectorComponent, FlyDataTableComponent, FlyDatePipe, FlyDateTimePipe, FlyDebouncer, FlyDecimalNumberPipe, FlyDetailCardComponent, FlyDetailShellComponent, FlyDrawerComponent, FlyDurationPipe, FlyDynamicFormComponent, FlyEmojiPickerComponent, FlyFieldComponent, FlyFileDownloadService, FlyFileUploadComponent, FlyFilterPanelComponent, FlyFormBannerComponent, FlyFormFooterComponent, FlyFormGridComponent, FlyFormSectionComponent, FlyFullNumberPipe, FlyGanttComponent, FlyHubClient, FlyIconButtonComponent, FlyIfAdminDirective, FlyIfRoleDirective, FlyImageUploadComponent, FlyLeaderboardComponent, FlyMagicActionsComponent, FlyMetaListComponent, FlyModalComponent, FlyModerationQueueComponent, FlyModuleIconDirective, FlyPaginationComponent, FlyPeoplePickerComponent, FlyPointsTierComponent, FlyProgressComponent, FlyRelativeTimePipe, FlyRemoteContextService, FlyRemoteRouter, FlyRemoteRouterOutletComponent, FlySearchInputComponent, FlySectionHeaderComponent, FlySecureSrcDirective, FlySegmentedComponent, FlySelectComponent, FlySkeletonComponent, FlySliderComponent, FlySparklineComponent, FlySpinnerComponent, FlyStandaloneAuthCallbackComponent, FlyStandaloneAuthService, FlyStateMessageComponent, FlyDynamicFormComponent as FlySurveyFormComponent, FlyTabComponent, FlyTabsComponent, FlyTagsInputComponent, FlyThemeService, FlyTimePipe, FlyToastService, FlyToggleComponent, FlyTooltipDirective, FlyTreeNavComponent, FlyTypeaheadComponent, FlyUserDirectoryService, FlyWindowHelpService, FlyWindowTitleService, FlyosPendingLaunchesGlobalKey, FlyosShellHandlesLaunchRequestsGlobalKey, FlyosShellOwnsHistoryGlobalKey, GANTT_ZOOMS, I18nService, LAUNCH_CONTEXT, MAGIC_BAR_SEARCH_WIDTH_DEFAULT, MAGIC_BAR_SEARCH_WIDTH_MAX, MAGIC_BAR_SEARCH_WIDTH_MIN, MagicBarRegistry, MessageBoxButtons, MessageBoxComponent, MessageBoxIcon, MessageBoxService, MockAuthService, NOVA_PRIORITY_TONE, NOVA_STATUS_TONE, NOVA_TONE_FALLBACK, OverlayStack, PRESENCE_COLORS, PageHeaderComponent, RTL_LOCALE_SET, SHARE_ORG_CHART_SYSTEM_KEY_APPS, SHARE_ORG_CHART_SYSTEM_KEY_DEFAULT, SHARE_PANEL_DEFAULT_FILE_LEVELS, STATE_DEFAULT_ICONS, STATE_DEFAULT_MESSAGE_KEYS, STEP_UP_CODE, STEP_UP_REAUTH_HANDLER, STEP_UP_RETURN_KEY, SUPPORTED_AGENT_PAYLOAD_VERSIONS, SharePanelComponent, SourceAppResolver, StandaloneWindowManagerService, StatusBadgeComponent, StepUpService, ToastHostComponent, TranslatePipe, WINDOW_DATA, WINDOW_HELP_HINT, WindowManagerService, applySkinTone, applySuggestion, ariaSort, buildCron, canConfirm, canGoNext, canGoPrev, captureFocus, clampMagicBarSearchWidth, clampPage, clampSliderValue, connectRemoteLaunch, enterActivatesNatively, filterGroup, filterSuggestions, findLocaleByDialect, findLocaleByPrefix, firstEnabledIndex, firstModuleIndex, flattenModules, flyAdminGuard, flyApiErrorMessage, flyCaptchaBase64Utf8, flyCaptchaBuildToken, flyCaptchaSha256Hex, flyCompactNumber, flyDebounced, flyDecimalNumber, flyDownloadBlob, flyDuration, flyEmojiFor, flyEmojiIsTonable, flyEmojiPackUrl, flyExportFileName, flyFirstEnabledIndex, flyFormatBytes, flyFormatDate, flyFormatDateTime, flyFormatTime, flyFullNumber, flyNextEnabledIndex, flyNextSegmentIndex, flyRelativeTime, flyResolveActiveTab, flyRoleGuard, flyScanPendingDelayMs, flyScanRetry, flySignedCompact, flySkinToneLabelKey, flyStandaloneAuthGuard, flyStandaloneAuthInterceptor, flyToDateOnly, flyToPage, flyUnwrap, flyUnwrapLenient, hasAnyRoleIn, healNativeFederationCacheOnce, initialExpanded, isAccentColor, isChunkLoadError, isFlyAuthStorePopulated, isNativeFederationCacheError, isRtlLocale, isRtlLocaleEntry, isValidCron, isValidSingleField, loadRemoteStyles, magicBarOwnerKey, magicBarSearchText, matchFlyRoutePattern, nextEnabledIndex, nextModuleIndex, nextSegmentIndex, nextSort, normalizeFlyTheme, normalizeRoles, novaPriorityToneVar, novaStatusToneVar, overlayStack, parseCron, parseStepUpChallenge, parseTags, presenceColorFor, printConsoleSecurityWarning, provideFlyChunkReloadRecovery, provideFlyEmojiPack, provideFlyStandaloneAuth, reloadOnceForChunkError, requestAppLaunch, resolveActiveModule, resolveActiveSection, resolveActiveTab, resolveCellValue, resolveStateIcon, resolveStateMessageKey, restoreFocus, sameTags, sectionHintKey, sectionLayout, sliderTrackGradient, sparklinePath, sparklinePoints, stepUpInterceptor, stepUpReturnKey, trimAgentPayload, trimAgentString, unloadRemoteStyles, utf8ByteLength, validateAgentPayload, warnIfEmbeddedSessionMissing };
+export type { ActionMenuItem, AgentAction, AgentActionDispatch, AgentActionVerb, AgentChipHostInputs, AgentCommand, AgentCommandContextBinding, AgentCommandHandle, AgentCommandRegistration, AgentCommandScope, AgentCommandSlashSpec, AgentDragPayload, AgentDraggableItem, AgentDropChipMode, AgentDropRendererRegistration, AgentEnvelopeAttachment, AgentMcpScope, AgentMessageEnvelope, AgentPayloadLimits, AgentPayloadValidationResult, AppEveryonePrincipal, AppEveryoneTerm, AppLookup, AppLookupEntry, AudienceEditTarget, AudienceErrorCode, AudienceFilter, AudienceOptions, AudiencePresetKind, AudienceTerm, AudienceTermKind, BreadcrumbItem, ButtonSize, ButtonVariant, CardDensity, CardLayout, ChartTerm, ChildWindowData, ChipTone, ConfirmKind, ConnectRemoteLaunchOptions, ContextMenuAlign, ContextMenuItem, ContextMenuSection, CronAdvancedFieldDef, CronMode, CronParts, CronWeekday, DesktopApp, DesktopAppCategory, DesktopAppKind, DetailSection, DialogResultWithAcknowledgement, EmbeddedSessionProbe, EntityLinkSelection, FilterGroup, FlyAchievementRow, FlyApiError, FlyApiResponse, FlyAppHomeLayout, FlyAppModule, FlyAppModuleSection, FlyAuthRefreshPayload, FlyAuthStoreReadable, FlyBadgeTile, FlyBreadcrumbItem, FlyCaptchaChallenge, FlyCaptchaSolution, FlyCaptchaState, FlyCellContext, FlyColumn, FlyColumnKind, FlyComment, FlyCommentDeleteRequest, FlyCommentEditRequest, FlyCommentLoadMoreRequest, FlyCommentLoadRepliesRequest, FlyCommentLockToggleRequest, FlyCommentPage, FlyCommentReportReason, FlyCommentReportRequest, FlyCommentReportStatus, FlyCommentSubmitRequest, FlyCountry, FlyCurrency, FlyCurrencyFetchFn, FlyCurrencySelectorMode, FlyCurrencySelectorValue, FlyDrawerBodyPadding, FlyDrawerPosition, FlyDrawerSide, FlyDrawerSize, FlyDrawerVariant, FlyEmojiCategory, FlyEmojiCell, FlyEmojiEntry, FlyEmojiPack, FlyEmojiPackEntry, FlyEmojiPackManifest, FlyEmojiPickerSize, FlyEmojiPickerTab, FlyEmojiSection, FlyFileInfo, FlyFileSelection, FlyFormAnswer, FlyFormAnswerValue, FlyFormDefinition, FlyFormFieldOptions, FlyFormOption, FlyFormQuestion, FlyFormQuestionType, FlyFormScoreDisplay, FlyLaunchEventDetail, FlyLaunchRequestDetail, FlyLeaderboardRow, FlyLiveRefreshOptions, FlyLocaleEntry, FlyMagicBarIconName, FlyMetaItem, FlyModerationLoadPageRequest, FlyModerationLockThreadRequest, FlyModerationOpenSubjectRequest, FlyModerationReport, FlyModerationReportPage, FlyModerationResolutionStatus, FlyModerationResolveRequest, FlyNavigableItem, FlyPageMeta, FlyPageResult, FlyPaged, FlyPeoplePickerMode, FlyPeoplePickerOption, FlyPeopleSearchFn, FlyPointsSummary, FlyRemoteContext, FlyRemoteEagerRoute, FlyRemoteLazyRoute, FlyRemoteLoadedComponent, FlyRemoteMatch, FlyRemoteRoute, FlyRemoteRouteEventDetail, FlySearchExpandTrigger, FlySearchInputSize, FlySecureSrcState, FlySelectOption, FlySelectValue, FlySkeletonAnimation, FlySkeletonLayout, FlySkeletonShape, FlySkinTone, FlySort, FlyStandaloneAuthConfig, FlyFileSelection as FlySurveyFileSelection, FlyFormAnswer as FlySurveyFormAnswer, FlyFormAnswerValue as FlySurveyFormAnswerValue, FlyFormDefinition as FlySurveyFormDefinition, FlyFormFieldOptions as FlySurveyFormFieldOptions, FlyFormOption as FlySurveyFormOption, FlyFormQuestion as FlySurveyFormQuestion, FlyFormQuestionType as FlySurveyQuestionType, FlyThemeMode, FlyTooltipPlacement, FlyTreeNavNode, FlyTypeaheadOption, FlyWindowHelpHintEventDetail, FlyWindowHelpPublisher, FlyWindowPageTitleEventDetail, FlyWindowTitlePublisher, FlyosPendingLaunches, FocusRestore, FormBannerKind, GanttDependency, GanttDependencyCreate, GanttRow, GanttRowDatesChange, GanttRowKind, GanttZoom, IconButtonVariant, LaunchContext, LoadBundleOptions, LookupDescriptor, LookupHandle, LookupRegistration, LookupResult, LookupSearch, MagicBarAction, MagicBarActionKind, MagicBarActionSpec, MagicBarActionView, MagicBarContribution, MagicBarGroup, MagicBarGroupSpec, MagicBarGroupView, MagicBarOwnerRef, MagicBarPublisher, MagicBarRadioMenu, MagicBarRadioMenuSpec, MagicBarRadioMenuView, MagicBarRadioOption, MagicBarSearch, MagicBarSearchSeed, MagicBarSearchSpec, MagicBarSearchView, MagicBarTextParams, MagicBarTone, MagicBarView, MessageBoxButton, MessageBoxDontAskAgainConfig, MessageBoxOptions, MessageBoxOptionsWithAcknowledgement, MockAuthConfig, OpenWindowOptions, OuPrincipal, OuTerm, OverlayHandle, PageHeaderVariant, PresetTerm, ProgressTone, RemoteAppDef, RequestAppLaunchOptions, RoleOuLookupRow, RolePrincipal, RolesTerm, SegmentedOption, ShareOrgChartOption, ShareOuNode, SharePanelLevelOption, SharePermissionEntry, SharePrincipal, SharePrincipalKind, ShareUserResult, StateMessageKind, StepUpChallenge, StepUpReauthHandler, StepUpReauthRequest, TabsVariant, ToastAction, ToastEntry, ToastOptions, ToastVariant, User, UserPrincipal, UsersTerm, WindowHelpHint, WindowInstance, WindowState };
 //# sourceMappingURL=flyos-design-system.d.ts.map