@ai-matrx/design-system 0.60.0 → 0.60.6

package/dist/organization-picker-mLqIcesx.d.ts

@@ -0,0 +1,875 @@
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+
+/**
+ * Switch — Radix switch, one implementation, two sizes.
+ *
+ * The four forks were the same control with two different tracks: a 16px track
+ * with a visible border and an overhanging thumb (matrx-frontend) and a 20px
+ * track with a transparent border and an inset thumb (matrx-extend, dashboard,
+ * workflow-studio). Both stay reachable through `size`, so no host has to keep
+ * a copy to keep its look:
+ *
+ *   sm → h-4 track, bordered, thumb sits proud of the rail
+ *   md → h-5 track, transparent border, thumb sits inside (the default)
+ *
+ * The unchecked track reads `bg-input`, the token that exists for exactly this
+ * — workflow-studio's fork used `bg-muted`, which is the surface token and
+ * makes an off switch disappear into a muted panel.
+ */
+
+type SwitchSize = "sm" | "md";
+interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> {
+    /** Track size. Default `md`. */
+    size?: SwitchSize;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Checkbox — Radix checkbox, and the indeterminate ruling that came with it.
+ *
+ * RADIX RENDERS THE INDICATOR FOR BOTH `checked` AND `"indeterminate"`. The
+ * stock shadcn body puts a full check inside it either way, so a half-selected
+ * "select all" tells the user every row is selected — a screen stating
+ * something false. The two states get different glyphs here, always.
+ *
+ * `size` carries the two boxes the hosts had forked into: matrx-frontend's
+ * dense 14px control and the stock 16px one.
+ */
+
+type CheckboxSize = "sm" | "md";
+interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    /** Box size. Default `md` (the stock 16px control); `sm` is the dense 14px one. */
+    size?: CheckboxSize;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Tooltip — the ONE tooltip in the fleet.
+ *
+ * THE COLLAPSE (0.6.0). Two implementations existed: matrx-frontend's
+ * `components/ui/tooltip.tsx` (182 import sites) and `@ai-matrx/tap-target`'s
+ * `src/tooltip.tsx` — the latter an explicit inlined PORT of the former,
+ * carrying a header that said so. tap-target shipped it only because its ~60
+ * tap buttons need a tooltip and no shared package owned one; four repos then
+ * adopted `TooltipProvider` from tap-target. That made tap-target — a
+ * button-geometry package — the accidental owner of a design-system primitive,
+ * with a second copy living in the biggest host.
+ *
+ * A tooltip is a design-system surface, so it lives here. tap-target now takes
+ * `@ai-matrx/design-system` as an ordinary sibling dependency and imports this
+ * file; its own copy is deleted, and its re-export removed. The DAG already
+ * ordered design-system before tap-target, so no cycle is introduced.
+ *
+ * BEHAVIOUR is matrx-frontend's, verbatim, including the ruling both copies
+ * carried in prose:
+ *
+ * 1. THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. The gate the
+ *    host wrapper once carried ("Radix generates dynamic aria-controls ids that
+ *    differ between SSR and client") was false: Radix ids come from React's
+ *    SSR-stable `useId`. It was actively harmful — a Trigger wraps
+ *    ALWAYS-VISIBLE content, so `return null` deleted that subtree from SSR and
+ *    the first client paint.
+ *
+ * 2. THE SURFACE IS TOKEN-DRIVEN, NOT BRANDED. Popover tokens, not
+ *    `bg-primary`: rich tooltip content using `text-muted-foreground` was
+ *    illegible on a brand-coloured background in one theme or the other.
+ *    Since 2026-09-28 the `.matrx-tooltip` class re-scopes those tokens to a dark,
+ *    high-contrast chip in both themes (styles.css, THE TOOLTIP SURFACE): the
+ *    neutral white surface it wore before was indistinguishable from the
+ *    browser's own `title` box.
+ *
+ * 3. EVERY `title` IS THIS TOOLTIP. The provider installs the title takeover
+ *    (`title-tooltips.ts`), so a hand-written `title=` anywhere in the
+ *    document shows this surface, never the browser's.
+ *
+ * SEAM INVERSION. The host resolved nested portal targets through
+ * `useNestedPortalContainer` (an app hook wired to its dialog + window-panel
+ * systems); tap-target's port dropped that seam entirely and always portalled
+ * to `document.body` — which is why a tooltip inside a popped-out panel landed
+ * in the wrong window. Here it is the package's `PortalContainerProvider`
+ * seam: an explicit `container` prop wins, then the injected container, then
+ * `document.body`. Both prior behaviours are reachable; neither is forked.
+ */
+
+interface TooltipProviderProps extends React.ComponentProps<typeof TooltipPrimitive.Provider> {
+    /**
+     * THE TITLE TAKEOVER (2026-09-28) — while any provider is mounted, every native
+     * `title` attribute in the document shows as this tooltip instead of the
+     * browser's (see `title-tooltips.ts`). On by default, because a rule every
+     * author must remember is a rule that is broken; pass `false` only for a
+     * surface that must keep the browser's own box. One provider opting out does
+     * not turn it off while another one is mounted.
+     */
+    titleTooltips?: boolean;
+}
+/**
+ * Mount once near the app root. Every tooltip in the tree shares its
+ * `delayDuration` / `skipDelayDuration` timing, and the root provider takes
+ * over native `title` attributes (see `titleTooltips`).
+ */
+declare function TooltipProvider({ titleTooltips, ...props }: TooltipProviderProps): React.JSX.Element;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+/**
+ * Stamps `data-matrx-tooltip-trigger` so the title takeover never draws a
+ * second tooltip over a control that already has this one — it still lifts a
+ * `title` on the same control, so the browser's box never doubles it either.
+ */
+declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    /**
+     * Explicit portal target; wins over the injected `PortalContainerProvider`
+     * value. Pass `null` to force `document.body`.
+     */
+    container?: HTMLElement | null;
+    /**
+     * Package-owned open/close motion. Default `true`. Pass `false` for a
+     * surface that must appear instantly. It is NOT the reduced-motion switch;
+     * `styles.css` already honours `prefers-reduced-motion`.
+     */
+    animated?: boolean;
+}
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu — Radix dropdown with two behaviours the stock body lacks.
+ *
+ * 1. THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. A wrapper in
+ *    matrx-frontend once deferred rendering until after hydration on a false
+ *    premise (Radix ids come from React's SSR-stable `useId`), which deleted
+ *    the always-visible trigger — buttons, `…` menus — from SSR and the first
+ *    client paint.
+ *
+ * 2. A LONG MENU SCROLLS INSTEAD OF GROWING OFF-SCREEN. Content and SubContent
+ *    cap at `--radix-dropdown-menu-content-available-height` — the space Radix
+ *    actually measured between the trigger and the viewport edge — and scroll
+ *    past it. Without the cap a menu longer than the viewport puts its last
+ *    items where no pointer can reach them, and on a short window that can be
+ *    the only exit from the surface.
+ *
+ * Portalling goes through the package's `usePortalContainer` seam, so a menu
+ * opened inside a Dialog mounts INSIDE the dialog (staying in the scroll
+ * shard, where its wheel events work) instead of at `document.body`. An
+ * explicit `container` prop still wins.
+ *
+ * Icons are the package's inlined SVGs (C19) — no icon-library dependency.
+ */
+
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * A SUBMENU OPENS BESIDE ITS PARENT, NEVER ON TOP OF IT (merged-grid review 2, C1: "nested
+ * submenus overlap the parent menu"). The submenu was drawn INSIDE the parent's surface, and that
+ * surface's entry animation leaves a `transform` on it — which makes the parent the containing
+ * block of the submenu's `position: fixed`. Radix measured the submenu's place in viewport
+ * coordinates and the browser applied them from the parent's corner, so it landed over the parent
+ * (and was clipped by the parent's scroll box). Portalled like every other surface, through the
+ * same container seam, it sits beside its trigger as Radix placed it.
+ */
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    container?: HTMLElement | null;
+} & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuContentProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> {
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+}
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+/**
+ * ContextMenu — the right-click menu primitive.
+ *
+ * THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. The gate a
+ * matrx-frontend wrapper once carried ("Radix generates dynamic aria-controls
+ * ids that differ between SSR and client") was false twice over: a CLOSED
+ * `ContextMenuTrigger` renders only `data-state` / `data-disabled` and emits
+ * no id at all, so there was never a mismatch to defend against. And the gate
+ * was actively harmful: the Trigger wraps ALWAYS-VISIBLE content, so `return
+ * null` deleted the wrapped subtree from the server render and the first
+ * client render — around a list row, that means the list paints EMPTY and
+ * fills in after hydration. Gating the Root would additionally orphan any
+ * Trigger rendered beneath it.
+ *
+ * That history is exactly why this belongs in the package: the same repo had
+ * already accumulated two copies of this wrapper, one gated and one not, with
+ * the CORRECT one sitting unused beside the defective one.
+ *
+ * This is the PRIMITIVE only. A host's actual right-click menu SYSTEM — the
+ * sections, the copy/export/convert actions, the surface registry — composes
+ * these parts and stays host-owned; nothing here knows what an action is.
+ *
+ * Portalling goes through the package's `usePortalContainer` seam so a menu
+ * raised inside a Dialog mounts inside it; an explicit `container` wins.
+ */
+
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/** Portalled like its parent, so it opens BESIDE it — see `DropdownMenuSubContent` for why. */
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    container?: HTMLElement | null;
+} & React.RefAttributes<HTMLDivElement>>;
+interface ContextMenuContentProps extends React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content> {
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+}
+declare const ContextMenuContent: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+/**
+ * Dialog — the modal surface, carrying every ruling the host forks paid for.
+ *
+ * Four hosts shipped four dialogs. Three were the stock shadcn body: a
+ * fixed-size centered card with `overflow: visible`. matrx-frontend's had been
+ * hardened, incident by incident, and those hardenings are the reason this
+ * component belongs in the package rather than being copied a fifth time:
+ *
+ * 1. THE ROOT RENDERS UNCONDITIONALLY — no hydration mount gate. The gate a
+ *    wrapper once carried ("Radix ids differ between SSR and client") was
+ *    false — Radix ids come from React's SSR-stable `useId` — and it deleted
+ *    the always-visible Trigger from SSR and the first client paint.
+ *
+ * 2. THE DIALOG IS CLAMPED TO THE VIEWPORT AND SCROLLS INSIDE ITSELF. Proven
+ *    live: an admin "Create Category" dialog rendered 851px tall in a 657px
+ *    viewport with `overflow-y: visible`, so its Create button sat below the
+ *    fold, unreachable. The only way out was a backdrop click — which
+ *    dismisses WITHOUT writing, and is indistinguishable from a silent save
+ *    failure. `max-h-[85dvh] overflow-y-auto` is the cap.
+ *
+ * 3. THE PRIMARY ACTION IS ALWAYS PRESSABLE — AND NEVER ON TOP OF THE BODY.
+ *    `DialogFooter` is sticky and bleeds to the card's edges using
+ *    `--dialog-pad`. Until 0.11.3 that bleed was a NEGATIVE BLOCK MARGIN,
+ *    which sticky clamps: the footer was dragged up over the row above it by
+ *    `--dialog-pad` minus the card gap. The card now RESERVES the footer's
+ *    block size instead (`.matrx-dialog-card` in `styles.css` hands its bottom
+ *    padding to the footer), so scrolled content never shows through beneath
+ *    the actions AND the footer never covers the row above it. Outside a
+ *    DialogContent both variables are unset, the padding falls back to `0px`,
+ *    and the footer is the plain row it always was.
+ *
+ * 4. ON MOBILE THE SAME DIALOG IS A BOTTOM SHEET — full width, bottom
+ *    anchored, height-capped, internally scrollable, safe-area padded. Opt out
+ *    with `mobileSheet={false}` only for the rare surface that must stay
+ *    centered (a tiny spinner). The sheet geometry is re-asserted AFTER the
+ *    caller's className so a desktop `max-w-2xl` cannot un-fullscreen it.
+ *
+ * 5. AN UNTITLED DIALOG IS STILL ACCESSIBLE. Radix warns (correctly) that
+ *    every dialog needs a title; rather than let hosts ship the warning, a
+ *    visually-hidden title is injected when the tree has none, and
+ *    `aria-describedby` is dropped when there is no description rather than
+ *    pointing at nothing.
+ *
+ * 6. ON DESKTOP A DIALOG IS A WINDOW, NOT A WALL (0.38.0, Arman 2026-09-23:
+ *    "none of the built-in page ai integrations are accessible because the
+ *    page is totally blocked"). Unless the caller passes `modal`, a desktop
+ *    dialog does not block the page: no overlay, the page, the Agents menu,
+ *    the assist dock and right-click AI stay usable beside it. It behaves like
+ *    a window: a click outside never closes it (`dismissOnOutsideClick` opts a
+ *    quick picker back in), Escape closes it only while focus is inside it
+ *    (Escape in the page belongs to the page), and its `DialogHeader` drags
+ *    it, clamped on screen, double-click to recenter. On a phone it stays the
+ *    blocking bottom sheet — nothing useful sits behind a sheet. Confirmations
+ *    are `AlertDialog`, a different component, and stay blocking. This is a
+ *    LIGHT window: the host's heavy window manager (tray, persistence) is a
+ *    separate system and must not be pulled into every dialog.
+ *
+ * SEAM INVERSIONS. The host original resolved its portal target through
+ * app-shaped hooks (a popped-out window-panel body). Here that is the
+ * package's `PortalContainerProvider` seam, with an explicit `container` prop
+ * keeping top priority. And DialogContent PROVIDES that seam to its own
+ * children, so a Popover or menu opened inside a dialog portals INTO the
+ * dialog — staying inside the scroll shard, where its wheel events work.
+ * `useDialogContainer` exposes the same element for host code that needs it.
+ */
+
+declare const Dialog: {
+    ({ children, ...props }: React.ComponentPropsWithoutRef<typeof DialogPrimitive.Root>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Portal-seam-aware DialogPortal. An explicit `container` always wins; with
+ * none, the injected `PortalContainerProvider` value decides; with neither,
+ * Radix's `document.body`.
+ */
+declare const DialogPortal: {
+    ({ container, ...props }: Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Portal>, "container"> & {
+        /** `undefined` → use the injected container; `null` → force document.body. */
+        container?: HTMLElement | null | undefined;
+    }): React.JSX.Element;
+    displayName: string;
+};
+/** The DialogContent element, for host code that portals into the dialog. */
+declare const useDialogContainer: () => HTMLElement | null;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Unstyled, non-portalling Content for custom dialog layouts. Preserves Radix
+ * focus/background behavior and derives `aria-modal` from the Root.
+ */
+declare const DialogContentPrimitive: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    /**
+     * Windowed (non-blocking) dialogs never close from a click outside them —
+     * the person is reaching for the page or an AI control beside the window.
+     * Pass `true` for a quick picker that should close when the person clicks
+     * away. Ignored on a blocking dialog, which keeps Radix's behaviour.
+     */
+    dismissOnOutsideClick?: boolean;
+    /** Render as a bottom sheet below the mobile breakpoint. Default `true`. */
+    mobileSheet?: boolean;
+    /** Render the built-in close control. Default `true`. */
+    showCloseButton?: boolean;
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+    /**
+     * Package-owned open/close motion. Default `true`. Pass `false` for a
+     * surface that must appear instantly. It is NOT the reduced-motion switch;
+     * `styles.css` already honours `prefers-reduced-motion`.
+     */
+    animated?: boolean;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+
+/**
+ * ConfirmDialog — the `window.confirm` replacement, declarative half.
+ *
+ * WHY IT LIVES HERE AND NOT IN `@ai-matrx/kit` (census row 19i, decided by the
+ * package-graph ruling of 2026-09-07, on the row-20a Tooltip precedent).
+ *
+ * kit shipped this dialog with its own inlined AlertDialog, its own inlined
+ * button class strings, a hardcoded 80%-opaque black scrim, and
+ * `data-[state=open]:animate-in … zoom-in-95 … slide-in-from-top-[48%]` —
+ * host-plugin utilities `tailwindcss-animate`/`tw-animate-css` supply and a
+ * package cannot ship. kit ships NO stylesheet at all, so in three of the four
+ * consumers the most consequential surface in the app (the one standing
+ * between a user and a destroyed thing) appeared with no animation, no error,
+ * and a scrim that ignored the theme. kit could not import the fix:
+ * `@ai-matrx/design-system` depends on `@ai-matrx/kit`, so importing back is a
+ * cycle; giving kit its own sheet would invent a second required-CSS contract
+ * no consumer performs (the C26 silent host contract, one layer down).
+ *
+ * The resolution is the one row 20a already proved: the surface moves to the
+ * package that owns the surface. This file is built on THIS package's
+ * `AlertDialog` — so it inherits, for free and forever:
+ *
+ *   - the package motion layer (`matrx-motion-overlay` / `matrx-motion-dialog`),
+ *     whose rules ship in `styles.css` and are proven present in the tarball;
+ *   - `--matrx-overlay-scrim`, a token that answers to the host's theme,
+ *     instead of an opaque black literal;
+ *   - AlertDialog ruling 3 — clamped to `max-h-[85dvh]`, scrolling inside
+ *     itself, with a sticky footer. **This is what makes the consequence-first
+ *     copy law survivable**: a confirmation that names everything it is about
+ *     to destroy can be long, and in kit's copy a long one pushed Cancel and
+ *     Continue below the fold of a short viewport with no backdrop dismissal —
+ *     a dead end on a destructive action;
+ *   - `buttonVariants` as the ONE source of button appearance, including the
+ *     44px coarse-pointer target;
+ *   - `PortalContainerProvider`, so a dialog opened inside a popped-out window
+ *     panel renders in THAT window's document.
+ *
+ * kit keeps `./confirm-opener` — the pure, React-free imperative `confirm()`
+ * and its `globalThis`-slotted host registry — and re-exports nothing of this.
+ * Consumers mount `<ConfirmDialogHost />` from here and call `confirm()` from
+ * there. See `confirm-host.tsx` for the join.
+ *
+ * BEHAVIOR IS THE KIT PORT, VERBATIM. Every prop, default and interaction is
+ * unchanged; only the chrome underneath it is the package's.
+ *
+ * Pattern: hold the pending target in state, render `<ConfirmDialog />` once at
+ * the bottom of the component, and open it by setting the target. When busy
+ * state is meaningful (a network delete that should hold the dialog open with a
+ * spinner), use THIS component inline; the imperative `confirm()` closes
+ * immediately on click.
+ */
+
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: React.ReactNode;
+    /**
+     * THE CONSEQUENCE. Per the platform's destructive-and-expensive-actions law,
+     * a confirmation must name what is lost, what is duplicated, and/or what it
+     * costs — "Are you sure?" is not a confirmation. This renders as the dialog's
+     * accessible description, so a screen-reader user is told the consequence
+     * too, and it is never clamped or truncated.
+     */
+    description?: React.ReactNode | undefined;
+    /**
+     * Rich body rendered between the header and the footer. Use it for
+     * supplementary or interactive content that is not part of the dialog's
+     * accessible consequence description.
+     */
+    content?: React.ReactNode | undefined;
+    /** Extra classes for the dialog content (e.g. a wider max-w for diffs). */
+    contentClassName?: string | undefined;
+    confirmLabel?: string | undefined;
+    /**
+     * `null` hides the cancel button entirely — for acknowledge-only dialogs
+     * where there is nothing to cancel. Anything else labels it.
+     */
+    cancelLabel?: string | null | undefined;
+    variant?: "default" | "destructive" | undefined;
+    busy?: boolean | undefined;
+    /**
+     * Blocks confirming without pretending work is in flight. For a dialog whose
+     * `content` asks the user something the action cannot proceed without — the
+     * choice is missing, not loading — `busy` would show a misleading spinner.
+     */
+    confirmDisabled?: boolean | undefined;
+    /**
+     * The question is not answerable yet — Confirm is ABSENT, not disabled (a
+     * control is absent or honest, never dead). The body carries its own loading
+     * state; Cancel stays. Set by `ConfirmDialogHost` while `ConfirmOptions.ready`
+     * is pending (0.54.0).
+     */
+    confirmHeld?: boolean | undefined;
+    /**
+     * Explicit portal target. Default (undefined): the container injected by
+     * `PortalContainerProvider`, else `document.body`. Hosts with retargeting
+     * needs (a popped-out browser window whose dialog must render in THAT
+     * window's document) may still pass the element directly.
+     */
+    portalContainer?: HTMLElement | null | undefined;
+    onConfirm: () => void | Promise<void>;
+}
+/**
+ * Drop-in replacement for `window.confirm`. Use this anywhere you would
+ * otherwise reach for a browser-level confirm dialog.
+ */
+declare function ConfirmDialog({ open, onOpenChange, title, description, content, contentClassName, confirmLabel, cancelLabel, variant, busy, confirmDisabled, confirmHeld, portalContainer, onConfirm, }: ConfirmDialogProps): React.JSX.Element;
+
+declare function ConfirmDialogHost(): React.JSX.Element;
+
+/**
+ * Popover — ported verbatim from matrx-frontend `components/ui/popover.tsx`.
+ *
+ * Seam inversion: the host's `useNestedPortalContainer` (dialog/popout aware)
+ * becomes the injected `PortalContainerProvider` seam (`portal-container.tsx`);
+ * the explicit `container` prop keeps top priority, exactly as before.
+ *
+ * THE ROOT RENDERS UNCONDITIONALLY — no mount gate. This wrapper used to defer
+ * rendering until after hydration ("Radix generates dynamic aria-controls ids
+ * that differ between SSR and client"), and that justification was false:
+ * Radix ids come from React's SSR-stable `useId` (verified against
+ * @radix-ui/react-popover 1.1.17 / react-id 1.1.2). The gate was actively
+ * harmful — the Trigger wraps ALWAYS-VISIBLE content, so `return null`
+ * deleted it from SSR and the first client paint.
+ */
+
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+interface PopoverContentProps extends React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> {
+    /** Explicit portal target; wins over the injected container. */
+    container?: HTMLElement | null;
+    /**
+     * Package-owned open/close motion. Default `true`. Pass `false` for a
+     * surface that must appear instantly — a picker re-anchoring while the user
+     * types, a measurement pass. It is NOT the reduced-motion switch;
+     * `styles.css` already honours `prefers-reduced-motion`.
+     */
+    animated?: boolean;
+    /**
+     * HOW WIDE THE POPOVER IS ALLOWED TO BE, and it is the SYSTEM that decides — never a
+     * surface pasting its own `w-64` over the default (lane FIX-14, 2026-09-22).
+     *
+     * `"fixed"` (default) is the historical `w-72`: right for a menu of short, known
+     * labels, where a ragged edge would look broken.
+     *
+     * `"content"` is for a popover whose whole job is to SHOW SOMETHING THE SYSTEM DID
+     * NOT CHOOSE — a person's name, a record's title, a row the user is about to
+     * create. The relation picker offered
+     *
+     *     Create “Marisol Okonkwo — 418 Calle Pu
+     *
+     * inside a 16rem box, cut mid-word, on the one control that exists to show the name
+     * being created. A fixed width cannot be right for content of unknown length, so
+     * this one grows to its content between an honest floor and an honest ceiling:
+     *
+     *   · at least the trigger's own width, and at least 20rem — the width Airtable's and
+     *     Notion's link-record pickers settle on, and wide enough that an ordinary
+     *     "name — street, town" fits on one line;
+     *   · at most 28rem, and never wider than the viewport less a 1rem gutter each side,
+     *     so it still fits a 375px phone with nothing running off the screen. The floor is
+     *     clamped by the same gutter, so on a very narrow screen the ceiling still wins.
+     *
+     * Beyond that ceiling the CONTENT truncates with an ellipsis and carries a `title`.
+     * Growing, then ellipsis — never a mid-word cut.
+     *
+     * BOTH modes keep the phone gutter (2026-09-26): the box is never wider than the
+     * viewport less 1rem each side, and Radix keeps it `collisionPadding` (16px) off every
+     * screen edge. Measured at 375px before this: `w-72`/`w-80` callers landed flush on
+     * the right edge (55→375) because collision padding was 0.
+     */
+    sizing?: "fixed" | "content";
+}
+declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Collapsible — Radix's, with the one thing Radix does not ship: the open/close
+ * transition.
+ *
+ * THE ROOT RENDERS UNCONDITIONALLY — no mount gate. The matrx-frontend
+ * original carried the note that earned this line: a wrapper used to defer
+ * rendering until after hydration on the theory that "Radix generates dynamic
+ * aria-controls ids that differ between SSR and client". That was false —
+ * Radix ids come from React's SSR-stable `useId` — and the gate was actively
+ * harmful, because a Collapsible's Trigger wraps ALWAYS-VISIBLE content, so
+ * `return null` deleted it from SSR and from the first client paint.
+ *
+ * THE TRANSITION IS PACKAGE-OWNED (census row 19f, the tail of 19c). Until
+ * 0.9.0 this file was a bare re-export and the package shipped NO transition,
+ * so every consumer invented its own — and two of them invented it wrong.
+ * `matrx-collapsible.tsx` and `enhanced-collapsible.tsx` put
+ * `animate-accordion-down`/`-up` on a COLLAPSIBLE panel: those keyframes
+ * interpolate to `--radix-ACCORDION-content-height`, a variable Radix never
+ * publishes on a collapsible, so they had never animated once — silently, with
+ * no error, for as long as they existed. Six other matrx-frontend components
+ * used host-only `animate-slide-down`/`-up` keyframes that WERE keyed
+ * correctly — and worked in exactly one app in the fleet, because the
+ * keyframes lived in that app's `globals.css`. Both shapes are the same C26
+ * failure: a component whose motion depends on a contract the host has to
+ * happen to hold. `.matrx-collapsible-content` in `styles.css` ends it — keyed
+ * off Radix's runtime `--radix-collapsible-content-height`, honouring
+ * `prefers-reduced-motion`, shipped in the tarball.
+ *
+ * Nothing else here is restyled: the trigger and the panel's own padding are
+ * the host's to dress, and every fork agreed on that. Unlike `AccordionContent`
+ * this component does NOT wrap children in a padding div — collapsibles in the
+ * fleet pad their own bodies, and inserting a box would move every one of them.
+ */
+
+declare const Collapsible: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface CollapsibleContentProps extends React.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.CollapsibleContent> {
+    /**
+     * Animate the height on open/close. Default `true`.
+     *
+     * Pass `false` for the rare panel that must not clip or must not move: the
+     * animated panel carries `overflow-hidden` (a height transition without it
+     * spills the body over whatever is below), so a panel with a child that
+     * deliberately overflows its bounds — a non-portalled popover, a sticky
+     * column header — opts out here rather than fighting the class. Opting out
+     * gives you bare Radix: instant open, no clipping, no keyframes.
+     *
+     * `prefers-reduced-motion` is NOT this prop's job; the stylesheet already
+     * drops the animation for those users while keeping the clipping.
+     */
+    animated?: boolean;
+}
+declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Skeleton — the "content is coming" placeholder.
+ *
+ * Ported from matrx-frontend `components/ui/skeleton.tsx`; no seams, pure
+ * markup over semantic tokens. ONE change from the original (0.10.0): the
+ * breathing loop is `.matrx-pulse`, a package-owned keyframe, not Tailwind's
+ * `animate-pulse`. A Skeleton that does not pulse is indistinguishable from an
+ * empty grey box — it stops saying "loading" and starts saying "nothing here"
+ * — so the motion is part of the component's meaning and ships with it (see
+ * `styles.css` § THE MOTION LAYER).
+ */
+
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Package-owned pulse. Default `true`. Pass `false` for a static
+     * placeholder — a print/PDF render, or a screenshot fixture where the
+     * animation makes the output non-deterministic. `prefers-reduced-motion`
+     * already SLOWS the pulse rather than stopping it (a still skeleton would
+     * lose the information), so this is not the accessibility switch.
+     */
+    animated?: boolean;
+}
+declare function Skeleton({ className, animated, ...props }: SkeletonProps): React.JSX.Element;
+
+/**
+ * A 6 px status mark. Tones read semantic tokens (`--info` blue, `--warning` orange,
+ * `--destructive` red, `--success` green), so a host re-tints them with its own values.
+ * `ring` is the hollow variant for icon corners, where a filled dot reads as "unread".
+ */
+type StatusTone = "info" | "warning" | "danger" | "success" | "neutral";
+interface StatusDotProps extends React.HTMLAttributes<HTMLSpanElement> {
+    tone: StatusTone;
+    variant?: "solid" | "ring";
+    /** Accessible name; without it the dot is decorative. */
+    label?: string;
+}
+declare function StatusDot({ tone, variant, label, className, ...props }: StatusDotProps): React.JSX.Element;
+
+/**
+ * The app rail: a narrow, never-changing strip of area icons on the far left, with the
+ * person at the bottom (Codex, VS Code, Slack, Teams). It answers "where am I"; the panel
+ * beside it answers "what can I do here". Width is the `--app-rail-width` knob (48 px).
+ */
+declare function AppRail({ className, style, ...props }: React.HTMLAttributes<HTMLElement>): React.JSX.Element;
+declare function AppRailGroup({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+/** Pushes everything after it to the bottom of the rail. */
+declare function AppRailSpacer(): React.JSX.Element;
+interface AppRailItemProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    icon: React.ReactNode;
+    label: string;
+    /** Shown in the tooltip after the label, e.g. "⌘1". */
+    shortcut?: string;
+    active?: boolean;
+    /** A hollow corner mark when the area needs attention; healthy areas carry none. */
+    attention?: StatusTone;
+    attentionLabel?: string;
+}
+declare const AppRailItem: React.ForwardRefExoticComponent<AppRailItemProps & React.RefAttributes<HTMLButtonElement>>;
+interface AppRailAvatarProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    /** Up to two letters. Ignored when `children` is given. */
+    initials?: string;
+    label: string;
+    /** A glyph instead of initials (e.g. a neutral person while signed out). */
+    children?: React.ReactNode;
+}
+/** The person, at the bottom of the rail (Codex's initials circle). */
+declare const AppRailAvatar: React.ForwardRefExoticComponent<AppRailAvatarProps & React.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * The canvas: a right-hand workspace of panels (terminal, files, browser, info) beside the
+ * main content, as in Claude desktop and Codex. Panels stack in columns, resize by dragging
+ * the gaps between them, and any one can expand to fill the whole canvas region.
+ *
+ * The layout is presentational: the host owns which panels are open, which is expanded and
+ * what each renders. The panel CHROME (CanvasPanel, CanvasPanelEmpty, BrowserTabs, BrowserBar)
+ * lives in @ai-matrx/canvas/react — the one canvas chrome; this package cannot depend on it
+ * (canvas → tap-target → design-system would be a cycle).
+ */
+interface CanvasPanelDef {
+    id: string;
+    node: React.ReactNode;
+    /** Pixels (number) or percent of the column (string). */
+    minSize?: number | string;
+    defaultSize?: number | string;
+}
+interface CanvasColumnDef {
+    id: string;
+    panels: CanvasPanelDef[];
+    minSize?: number | string;
+    defaultSize?: number | string;
+}
+interface CanvasLayoutProps {
+    columns: CanvasColumnDef[];
+    /** When set, only this panel renders, filling the layout. */
+    expandedId?: string | null;
+    className?: string;
+}
+declare function CanvasLayout({ columns, expandedId, className }: CanvasLayoutProps): React.JSX.Element;
+
+/**
+ * A small segmented group of icon buttons for switching the app's mode (Claude desktop's
+ * chat | code pair in the title bar). A radio group: arrow keys move, one is always checked.
+ */
+interface ModeSwitchOption<T extends string> {
+    value: T;
+    label: string;
+    icon: React.ReactNode;
+    shortcut?: string;
+}
+interface ModeSwitchProps<T extends string> {
+    value: T;
+    onValueChange: (value: T) => void;
+    options: ReadonlyArray<ModeSwitchOption<T>>;
+    label?: string;
+    className?: string;
+}
+declare function ModeSwitch<T extends string>({ value, onValueChange, options, label, className }: ModeSwitchProps<T>): React.JSX.Element;
+
+/**
+ * OrganizationPicker — THE ONE "which organization am I acting in" control,
+ * identical on every Matrx surface (the main app's user menu and header nudge,
+ * Workflow Studio's sidebar, the admin dashboard's settings).
+ *
+ * Ported from matrx-frontend `features/organizations/components/
+ * OrganizationPickerPanel.tsx` + `UserMenuOrgSection.tsx` + `DefaultOrgSwitch.tsx`
+ * (2026-09-08), which until then were the ONLY surfaces with the full picker;
+ * Studio and the dashboard each had a bare `<Select>` with different copy,
+ * different placement and no default control. Three UIs for one fact.
+ *
+ * THE ACTIVE ROW IS THE ANSWER (owner, 2026-10-01). The active organization is
+ * the highlighted row — tinted, bold, ringed and checked — and nothing else:
+ * the "Working in …" sentence above the list is gone ("It should be
+ * highlighted and clear"), and so is the "Keep it at the top" switch.
+ *
+ * FAVORITES (owner, 2026-10-01: "add a star you can click to favorite any of
+ * them"). Every row carries its own star; a person favorites as many as they
+ * like, and favorites are drawn first. The star never selects the row — it is
+ * a sibling button, not part of the row — and it picks no organization for
+ * anyone: which organization you are working in is this device's own
+ * remembered choice (the host's resolver), never a star.
+ *
+ * 🚨 A HUNDRED ROWS IS NOT A LIST (VERIFIER-8 MEDIUM-3, 2026-09-21).
+ * The first screen of the data product offered the admin account's 116
+ * organizations nine at a time, with no search, most of them lane fixtures.
+ * Three things answer that, and all three are here rather than in one host:
+ *   • SEARCH over name and abbreviation, once the list passes eight rows.
+ *   • TEST ORGANIZATIONS HIDDEN by default behind the platform's one
+ *     archive-style disclosure (`ArchivedDisclosure`), with their count always
+ *     on screen. Hidden, never dropped.
+ *   • THE PERSON'S OWN organizations drawn first, under the starred one.
+ * The host classifies (`isTestFixture`, `isOwn`); this component decides
+ * nothing about a name it is given.
+ *
+ * Seam inversions from the origin: lucide `Check`/`Star` become package
+ * SVGs (C19); the host `Switch` becomes this package's; `cn` is local.
+ */
+
+interface OrganizationPickerOrganization {
+    id: string;
+    name: string;
+    /** Database-validated 2–3 uppercase letters. Optional — not every report carries it. */
+    abbreviation?: string | null;
+    /**
+     * THE ADDRESS, for when the NAME is not enough — its slug, or whatever else the
+     * host has that tells two of them apart.
+     *
+     * 🚨 WHY (crew D2, 2026-09-21). Two organizations called "Kessler Lab for Applied
+     * Microbial Ecology" and two called "Wraithmoor Regional Museum of Art & Craft" sat
+     * in one list, identical down to the abbreviation tile, and a person had no way of
+     * knowing which one they were about to work in. The list drew the name and nothing
+     * else, so there was nothing for it to draw.
+     *
+     * It is shown ONLY on the rows whose name another row in the list also carries —
+     * the way Slack shows a workspace's URL and Google shows the account's email, and
+     * only where it settles the question. A list of distinct names stays exactly as it
+     * was, because a second line under every row is noise a person learns to skip.
+     */
+    distinguisher?: string | null;
+    /**
+     * This organization is a TEST FIXTURE — a lane's scratch organization, not a
+     * business anybody works in. Classified in `iam.organizations.settings`
+     * (`test_fixture`), never guessed from its name.
+     *
+     * 🚨 WHY (VERIFIER-8 MEDIUM-3, 2026-09-21). The admin account belongs to 116
+     * organizations and 59 of them are fixtures. The first screen of the data
+     * product offered all of them, nine at a time, with no search — so the two
+     * or three a person actually works in were buried under lane debris. The
+     * archived-items law already answers this shape everywhere else in the
+     * platform: hide by default, ONE disclosure to reveal, and the count of what
+     * is hidden is always on screen. It is hidden, never dropped: a fixture the
+     * person genuinely wants is one click away.
+     */
+    isTestFixture?: boolean;
+    /**
+     * The signed-in person created this organization. Drawn before the rest,
+     * under the starred one — the same reason Slack puts your own workspace
+     * first: in a list of a hundred, yours must not be something you search for.
+     */
+    isOwn?: boolean;
+    /**
+     * A short trailing label for the row — what a click does or the row's state
+     * ("Open", "Finish setup", "Turn on HR"). Muted text, right-aligned; the row
+     * stays one button. Omitted, the row is exactly as before.
+     */
+    detail?: string | null;
+    /**
+     * Fold this row behind the host's second disclosure (`foldedLabel`) — for rows
+     * the person rarely came for (organizations without HR). Hidden, counted,
+     * one click away; a search that matches only folded rows opens the fold.
+     */
+    folded?: boolean;
+}
+interface OrganizationPickerProps {
+    organizations: readonly OrganizationPickerOrganization[];
+    /** The organization the person is acting in right now; null = nothing chosen. */
+    activeOrganizationId: string | null;
+    /** The person's favorite organizations, drawn first and starred. */
+    favoriteOrganizationIds?: readonly string[];
+    loading?: boolean;
+    /** Memberships could not be read. The panel says so instead of showing an empty list. */
+    loadFailed?: boolean;
+    /** Choose the active organization. Hosts persist + refetch here. */
+    onSelect: (organization: OrganizationPickerOrganization) => void;
+    /**
+     * Favorite (true) or unfavorite (false) one organization. Omit to draw no
+     * star buttons — a host with no write path must not show a control that
+     * does nothing (a favorite is still marked, read-only).
+     */
+    onToggleFavorite?: ((organizationId: string, favorite: boolean) => void) | undefined;
+    /** Hide the "Organization" eyebrow when the host already labels the section. */
+    hideHeading?: boolean;
+    /** Extra classes on each row button (e.g. a host menu's item class). */
+    itemClassName?: string;
+    /** The noun on the disclosure that holds `folded` rows. Default "More". */
+    foldedLabel?: string;
+    className?: string;
+}
+declare function organizationColor(seed: string): {
+    background: string;
+    color: string;
+};
+/**
+ * THE organization mark — its own logo when it has one, otherwise its 2–3
+ * letter abbreviation on its colour tile (the first letter of the name when the
+ * report has no abbreviation, so a tile is never empty). Three letters get a
+ * smaller face than two so they fit the tile. Every Matrx surface draws this.
+ */
+declare function OrganizationMark({ id, name, abbreviation, logoUrl, size, className, }: {
+    /** Seeds the colour; the name is used when absent. */
+    id?: string | null | undefined;
+    name: string;
+    abbreviation?: string | null | undefined;
+    logoUrl?: string | null | undefined;
+    size?: number;
+    className?: string | undefined;
+}): React.JSX.Element;
+declare function OrganizationPicker({ organizations, activeOrganizationId, favoriteOrganizationIds, loading, loadFailed, onSelect, onToggleFavorite, hideHeading, itemClassName, foldedLabel, className, }: OrganizationPickerProps): React.JSX.Element;
+
+export { PopoverContent as $, AppRail as A, DialogFooter as B, type CanvasColumnDef as C, Dialog as D, DialogHeader as E, DialogTitle as F, DialogTrigger as G, DropdownMenu as H, DropdownMenuCheckboxItem as I, DropdownMenuContent as J, DropdownMenuGroup as K, DropdownMenuItem as L, DropdownMenuLabel as M, DropdownMenuRadioGroup as N, DropdownMenuRadioItem as O, DropdownMenuSeparator as P, DropdownMenuShortcut as Q, DropdownMenuSub as R, DropdownMenuSubContent as S, DropdownMenuSubTrigger as T, DropdownMenuTrigger as U, ModeSwitch as V, type ModeSwitchOption as W, type ModeSwitchProps as X, OrganizationMark as Y, Popover as Z, PopoverAnchor as _, AppRailAvatar as a, PopoverTrigger as a0, Skeleton as a1, StatusDot as a2, type StatusDotProps as a3, type StatusTone as a4, Switch as a5, type SwitchProps as a6, Tooltip as a7, TooltipContent as a8, type TooltipContentProps as a9, type SwitchSize as aA, type TooltipProviderProps as aB, useDialogContainer as aC, TooltipProvider as aa, TooltipTrigger as ab, organizationColor as ac, type CheckboxSize as ad, type CollapsibleContentProps as ae, ContextMenuCheckboxItem as af, type ContextMenuContentProps as ag, ContextMenuGroup as ah, ContextMenuLabel as ai, ContextMenuPortal as aj, ContextMenuRadioGroup as ak, ContextMenuRadioItem as al, ContextMenuSub as am, ContextMenuSubContent as an, ContextMenuSubTrigger as ao, DialogContentPrimitive as ap, type DialogContentProps as aq, DialogOverlay as ar, DialogPortal as as, type DropdownMenuContentProps as at, DropdownMenuPortal as au, OrganizationPicker as av, type OrganizationPickerOrganization as aw, type OrganizationPickerProps as ax, type PopoverContentProps as ay, type SkeletonProps as az, type AppRailAvatarProps as b, AppRailGroup as c, AppRailItem as d, type AppRailItemProps as e, AppRailSpacer as f, CanvasLayout as g, type CanvasLayoutProps as h, type CanvasPanelDef as i, Checkbox as j, type CheckboxProps as k, Collapsible as l, CollapsibleContent as m, CollapsibleTrigger as n, ConfirmDialog as o, ConfirmDialogHost as p, type ConfirmDialogProps as q, ContextMenu as r, ContextMenuContent as s, ContextMenuItem as t, ContextMenuSeparator as u, ContextMenuShortcut as v, ContextMenuTrigger as w, DialogClose as x, DialogContent as y, DialogDescription as z };