asma-ui-core 3.104.0 → 3.106.0

package/dist/src/components/custom/module/header-layout/ToolbarActionGroup.d.ts

@@ -1,19 +1,30 @@
+import { ReactNode } from 'react';
 import { DynamicToolbarAction, PlannedToolbarActions } from './planToolbarActions';
+/** More-menu item state: a running action is disabled with the busy reason (disabled-states DIS-8). */
+export declare function overflowItemState(action: DynamicToolbarAction, inProgressLabel?: string): {
+    disabled?: boolean;
+    disabledReason?: ReactNode;
+    'aria-busy'?: boolean;
+};
 /** True when the plan renders anything (inline buttons or the More menu). */
 export declare function hasPlannedActions(plan?: PlannedToolbarActions): boolean;
-export declare function ToolbarActionButton({ action, showLabel, selectionTone, }: {
+export declare function ToolbarActionButton({ action, showLabel, selectionTone, inProgressLabel, }: {
     action: DynamicToolbarAction;
     showLabel: boolean;
     selectionTone?: boolean;
+    /** Busy announcement of a `loading` action, in the toolbar locale. */
+    inProgressLabel?: string;
 }): JSX.Element;
 export declare function MoreTriggerButton({ overflowMenuLabel, onOpen, }: {
     overflowMenuLabel: string;
     onOpen?: (anchor: HTMLElement) => void;
 }): JSX.Element;
 /** Inline action buttons plus the "More" overflow menu for a planned strip. */
-export declare function ToolbarActionGroup({ plan, overflowMenuLabel, className, selectionTone, registerActionWidth, }: {
+export declare function ToolbarActionGroup({ plan, overflowMenuLabel, className, selectionTone, registerActionWidth, inProgressLabel, }: {
     plan: PlannedToolbarActions;
     overflowMenuLabel: string;
+    /** Reason and busy announcement of a `loading` action, in the toolbar locale. */
+    inProgressLabel?: string;
     className?: string;
     selectionTone?: boolean;
     /**

package/dist/src/components/custom/module/header-layout/ToolbarRows.d.ts

@@ -51,7 +51,7 @@ export declare function TitleBlock({ title, helperText, titleMeasureRef, }: {
  * Bulk actions render only in the `inline-selection` variant; the other
  * variants pair with a separate {@link SelectionRow} when selection is active.
  */
-export declare function UtilityCluster({ variant, beforeFilterActionsPlan, filter, search, afterSearchActionsPlan, bulkActionsPlan, showPageActions, overflowMenuLabel, searchMeasureRef, align, }: {
+export declare function UtilityCluster({ variant, beforeFilterActionsPlan, filter, search, afterSearchActionsPlan, bulkActionsPlan, showPageActions, overflowMenuLabel, inProgressLabel, searchMeasureRef, align, }: {
     variant: UtilityRowVariant;
     beforeFilterActionsPlan: PlannedToolbarActions;
     filter?: ReactNode;
@@ -60,6 +60,7 @@ export declare function UtilityCluster({ variant, beforeFilterActionsPlan, filte
     bulkActionsPlan?: PlannedToolbarActions;
     showPageActions: boolean;
     overflowMenuLabel: string;
+    inProgressLabel?: string;
     searchMeasureRef?: MeasureRef;
     align?: 'start' | 'end';
 }): JSX.Element | null;

package/dist/src/components/custom/module/header-layout/planToolbarActions.d.ts

@@ -1,4 +1,4 @@
-import { ReactElement } from 'react';
+import { ReactElement, ReactNode } from 'react';
 export interface DynamicToolbarActionRenderOptions {
     showLabel: boolean;
 }
@@ -8,6 +8,23 @@ export interface DynamicToolbarAction {
     onClick: () => void;
     icon?: ReactElement;
     disabled?: boolean;
+    /**
+     * Why the action is unavailable. With `disabled` the button or More-menu item stays focusable
+     * and shows the reason on hover, focus and tap (disabled-states DIS-1…DIS-3).
+     */
+    disabledReason?: ReactNode;
+    /**
+     * Busy: the button shows a spinner, sets `aria-busy` and ignores activation (disabled-states DIS-8).
+     * In the More menu the item is disabled with the reason "In progress" in the toolbar locale. Pass a
+     * boolean from the first render so the busy announcement region exists before it turns on.
+     */
+    loading?: boolean;
+    /**
+     * Whether a `loading` action keeps the dialog around it open (no Esc, backdrop, X or Cancel), inline
+     * and in the More menu; defaults to `true`, the rule for a running save (submit-buttons SUB-8). Pass
+     * `false` for an action that is not a save, such as a preview or a lookup.
+     */
+    holdsDialog?: boolean;
     hidden?: boolean;
     variant?: 'contained' | 'outlined' | 'text' | 'textGray' | 'textWhite';
     /** Visual tone. `danger` renders the action in the destructive/red palette. */

package/dist/src/components/custom/module/header-layout/useTranslations.d.ts

@@ -7,6 +7,7 @@ declare const translations: {
         back: string;
         menu: string;
         close: string;
+        inProgress: string;
     };
     no: {
         more: string;
@@ -15,6 +16,7 @@ declare const translations: {
         back: string;
         menu: string;
         close: string;
+        inProgress: string;
     };
 };
 export type ToolbarTranslations = (typeof translations)['en'];

package/dist/src/components/custom/widget/widget/StyledWidget.d.ts

@@ -25,6 +25,11 @@ export interface StyledWidgetProps {
         onClick?: () => void;
         hide?: boolean;
         disabled?: boolean;
+        /**
+         * @figmaProp none — behavioral. Why "view more" is unavailable. With `disabled` the button stays
+         * focusable and shows the reason on hover, focus and tap (disabled-states DIS-1…DIS-4).
+         */
+        disabledReason?: ReactNode;
     };
     /**
      * @param {string} persistKey - Unique key to persist expanded state

package/dist/src/components/data-display/chip/StyledChip.d.ts

@@ -27,6 +27,12 @@ export interface StyledChipProps {
     size?: 'small' | 'medium';
     /** @figmaProp State = true→"Disabled" */
     disabled?: boolean;
+    /**
+     * @figmaProp none — behavioral. Why a clickable chip is unavailable. With `disabled` the chip stays
+     * focusable (`aria-disabled`), ignores activation and shows the reason on hover, focus and tap
+     * (disabled-states DIS-1…DIS-3).
+     */
+    disabledReason?: ReactNode;
     /** @figmaProp State = true→"Read only" */
     readOnly?: boolean;
     /** @figmaProp State = drives interactive Hovered/Focused/Pressed via native events */

package/dist/src/components/data-display/interactive-chip/StyledInteractiveChip.d.ts

@@ -1,4 +1,4 @@
-import { ComponentProps } from 'react';
+import { ComponentProps, ReactNode } from 'react';
 import { StyledChip } from '../chip';
 /**
  * @figmaNode wXrXt5uKNNzV2DnQCgyYZH#13248-31089
@@ -19,6 +19,12 @@ export interface StyledInteractiveChipProps extends ComponentProps<typeof Styled
     size?: 'small' | 'medium';
     /** @figmaProp none — accessible name for the control */
     ariaLabel?: string;
+    /**
+     * @figmaProp none — behavioral. Why the chip can't be selected. With `disabled` the chip stays
+     * focusable (`aria-disabled`), ignores activation and shows the reason on hover, focus and tap
+     * (disabled-states DIS-1…DIS-4). Without `disabled` it has no effect.
+     */
+    disabledReason?: ReactNode;
 }
 /**
  * A `StyledChip` whose avatar is a native checkbox or radio (base-ui controls now render their own

package/dist/src/components/data-display/tooltip/StyledTooltip.d.ts

@@ -30,6 +30,19 @@ export interface TooltipProps {
     disableHoverListener?: boolean;
     disableFocusListener?: boolean;
     disableTouchListener?: boolean;
+    /**
+     * A tap on a touch screen toggles the tooltip; it stays until the next tap, a tap outside,
+     * scroll or Escape — never a timer (disabled-states DIS-2, §5). Hover stays mouse-only so the
+     * emulated mouse events after a tap cannot toggle it a second time.
+     */
+    openOnTap?: boolean;
+    /**
+     * The text stays in the DOM and the trigger references it through `aria-describedby` while the
+     * tooltip is closed, so a screen reader announces it on focus (disabled-states DIS-2, 4.1.2).
+     */
+    persistentDescription?: boolean;
+    /** Share the persistent description with every focusable item in a composite control. */
+    persistentDescriptionId?: string;
     offsetDistance?: number;
     className?: string;
     slotProps?: TooltipSlotProps;
@@ -37,8 +50,9 @@ export interface TooltipProps {
 /**
  * Tooltip built on `@floating-ui/react` (replaces MUI `Tooltip`) — hover(+`enterDelay`)/focus open,
  * dismiss on blur/esc, `flip`/`shift` collision handling, optional arrow, portalled. Empty `title`
- * renders the child alone (MUI parity). Preserves the `#363E4A` design and the `title`/`placement`/
+ * renders the child alone (MUI parity); a Fragment child keeps its `display: contents` wrapper so
+ * it does not remount when a title appears. Preserves the `#363E4A` design and the `title`/`placement`/
  * `arrow`/`enterDelay`/`open`/`slotProps` surface (DEC-003). TASK-301.
  */
-export declare const StyledTooltip: (props: TooltipProps) => JSX.Element;
+export declare const StyledTooltip: ({ children, ...props }: TooltipProps) => JSX.Element;
 export {};

package/dist/src/components/feedback/dialog/DialogBusy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/feedback/dialog/DialogBusyContext.d.ts

@@ -0,0 +1,28 @@
+import { ReactNode } from 'react';
+import { UiCoreLocale } from '../../../helpers/uiCoreLocale';
+export declare const WAIT_UNTIL_SAVED: {
+    readonly en: "Wait until saved";
+    readonly no: "Vent til lagringen er ferdig";
+};
+interface DialogBusyContextValue {
+    busy: boolean;
+    busyReason?: ReactNode;
+    /** Marks the dialog busy; the returned function ends that mark. */
+    registerBusy: () => () => void;
+}
+export declare const DialogBusyContext: import('react').Context<DialogBusyContextValue | null>;
+/**
+ * A dialog (or popover) is busy while one of its buttons runs an action (`StyledButton loading`, unless
+ * the button passes `holdsDialog={false}`).
+ * Closing it then would hide a request that is still running, so every dismissal (Esc, backdrop click,
+ * the X button) is ignored until the action ends (submit-buttons SUB-4/SUB-8: Cancel waits for the result).
+ * Provide `contextValue` with `DialogBusyContext.Provider` around the dialog content.
+ */
+export declare const useDialogBusyBoundary: (busyReason?: ReactNode, locale?: UiCoreLocale) => {
+    busy: boolean;
+    busyReason: ReactNode;
+    contextValue: DialogBusyContextValue;
+};
+/** Reports `busy` to the closest dialog, if any. Safe outside a dialog. */
+export declare const useReportDialogBusy: (busy: boolean) => void;
+export {};

package/dist/src/components/feedback/dialog/StyledDialog.d.ts

@@ -1,4 +1,5 @@
 import { CSSProperties, ReactNode, SyntheticEvent } from 'react';
+import { UiCoreLocale } from '../../../helpers/uiCoreLocale';
 export type DialogCloseReason = 'escapeKeyDown' | 'backdropClick';
 export type DialogMaxWidth = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | false;
 interface DialogPaperProps {
@@ -48,6 +49,10 @@ export interface IStyledDialogProps {
             onExited?: () => void;
         };
     };
+    /** Why close and Cancel wait while an action runs; defaults to "Wait until saved" in `locale`. */
+    busyReason?: ReactNode;
+    /** Language of the default busy reason; defaults to English. */
+    locale?: UiCoreLocale;
     onCloseText?: ReactNode;
     /** @figmaProp none — behavioral */
     showCloseIcon?: boolean;
@@ -55,9 +60,17 @@ export interface IStyledDialogProps {
     dialogLabel?: ReactNode;
     /** @figmaProp header Title (Page title 24 SemiBold, delta-800) */
     dialogTitle?: ReactNode;
-    /** Accessible name when the dialog has no visible title. */
-    ariaLabel?: string;
     dialogHeaderNode?: ReactNode;
+    /**
+     * @figmaProp none — accessibility
+     * The dialog's accessible name when it shows no visible title: neither `dialogTitle`, a
+     * `<StyledDialogTitle>` child nor `dialogLabel`. A visible title or label always wins: the dialog
+     * is `aria-labelledby` it. Without any of these, the dialog is named by the first heading
+     * (`h1`–`h6` or `role="heading"`) in its content; with no heading either it stays unnamed and a
+     * development-only warning names its `dataTest`. `dataTest` is never used as a name — it is a
+     * test hook, not text.
+     */
+    ariaLabel?: string;
 }
 /**
  * Modal dialog built on the native `<dialog>` element (replaces MUI `Dialog`) — backdrop, focus

package/dist/src/components/feedback/dialog/dialog-footer/StyledDialogFooter.d.ts

@@ -6,6 +6,7 @@ import { ToolbarLocale } from '../../../custom/module/header-layout/useTranslati
 export interface StyledDialogFooterButton {
     label: string;
     onClick?: () => void;
+    /** Rendered as `aria-disabled`, not native `disabled`: the button stays focusable, so keyboard users reach its `tooltip`. A click does nothing. */
     disabled?: boolean;
     /** `submit` lets the footer drive the surrounding `<form>` without a click handler. */
     type?: 'button' | 'submit' | 'reset';
@@ -17,16 +18,18 @@ export interface StyledDialogFooterButton {
     /** Trailing icon. `loading` supplies its own and wins. */
     endIcon?: ReactNode;
     /**
-     * Shows a spinner after the label and disables the button. Consumers previously swapped
-     * the label *for* a spinner, which changes the button's width mid-submit — hence the
-     * hard-coded `w-[98px]` workarounds in the footers this replaces. Keeping the label
-     * makes the width stable on its own.
+     * Marks the button busy: a spinner sits centred over the label, which stays in the layout
+     * (invisible, still the accessible name), so the button keeps its width. It keeps focus and
+     * ignores activation. Consumers previously swapped the label *for* a spinner, which changed
+     * the button's width mid-submit — hence the hard-coded `w-[98px]` workarounds in the footers
+     * this replaces.
      */
     loading?: boolean;
     /**
-     * Wraps the button in a `StyledTooltip`. Falsy renders no tooltip, so the common
-     * `tooltip={disabled && 'Locked for editing'}` reads naturally. A disabled button does
-     * not emit pointer events, so the tooltip is anchored on a wrapper around it.
+     * Pass a constant `tooltip` (e.g. 'Locked for editing') and toggle `disabled` separately.
+     * With `disabled` it is the reason the action is unavailable (`disabledReason`):
+     * the button stays focusable and shows it on hover, focus and tap. Otherwise it is a plain
+     * hint anchored on a wrapper.
      */
     tooltip?: ReactNode;
     dataTest?: string;

package/dist/src/components/feedback/dialog/index.d.ts

@@ -3,3 +3,4 @@ export * from './StyledDialogActions';
 export * from './StyledDialogContent';
 export * from './StyledDialogTitle';
 export * from './dialog-footer';
+export { DialogBusyContext, useDialogBusyBoundary, useReportDialogBusy } from './DialogBusyContext';

package/dist/src/components/feedback/minimizable-dialog/components/CloseBtn.d.ts

@@ -4,4 +4,6 @@ export declare const CloseBtn: React.FC<{
     onClick: () => void;
     tooltipTitle: string;
     buttonRef?: React.Ref<HTMLButtonElement>;
+    /** While set, the button is soft-disabled with this reason (e.g. a save is running). */
+    disabledReason?: React.ReactNode;
 }>;

package/dist/src/components/feedback/minimizable-dialog/types.d.ts

@@ -19,7 +19,18 @@ export interface IMinimizableDialogProps {
     children?: React.ReactNode | ((props: IFloatingWindowProps) => ReactNode);
     className?: string;
     primaryButtonText?: string;
+    /**
+     * @figmaProp none — behavioral. Busy: the primary button shows a spinner and ignores activation;
+     * the secondary button, Esc and the close button wait with the reason "Wait until saved" (DIS-8).
+     */
     primaryButtonLoading?: boolean;
+    /** @figmaProp none — behavioral. Disables the primary button; pair it with `primaryButtonDisabledReason`. */
+    primaryButtonDisabled?: boolean;
+    /**
+     * @figmaProp none — behavioral. Why the primary action is unavailable. With `primaryButtonDisabled`
+     * the button stays focusable and shows the reason on hover, focus and tap (disabled-states DIS-1…DIS-4).
+     */
+    primaryButtonDisabledReason?: ReactNode;
     secondaryButtonText?: string;
     onPrimaryButtonClick?: () => void;
     onSecondaryButtonClick?: () => void;

package/dist/src/components/feedback/minimizable-dialog/v2/types.d.ts

@@ -30,6 +30,8 @@ export interface IMinimizableDialogV2Props {
         fullscreen?: string;
     };
     locale?: ILocale;
+    /** Why Close and Cancel wait while an action inside runs; defaults to "Wait until saved" in `locale`. */
+    busyReason?: ReactNode;
     dataTest: string;
     style?: React.CSSProperties;
     /**

package/dist/src/components/feedback/minimizable-dialog/v2/useTranslations.d.ts

@@ -2,6 +2,7 @@ import { ILocale } from './types';
 declare const translations: {
     en: {
         close: string;
+        waitUntilSaved: string;
         expand: string;
         minimize: string;
         fullscreen: string;
@@ -9,6 +10,7 @@ declare const translations: {
     };
     no: {
         close: string;
+        waitUntilSaved: string;
         expand: string;
         minimize: string;
         fullscreen: string;

package/dist/src/components/inputs/button/StyledButton.d.ts

@@ -1,4 +1,5 @@
 import { default as React, ReactNode } from 'react';
+import { UiCoreLocale } from '../../../helpers/uiCoreLocale';
 export type StyledButtonType = 'contained' | 'outlined' | 'text' | 'textGray';
 interface commonProps {
     /** @figmaProp none — ref */
@@ -11,6 +12,29 @@ interface commonProps {
     endIcon?: ReactNode;
     /** @figmaProp none — test hook */
     dataTest: string;
+    /**
+     * @figmaProp none — behavioral. Why the action is unavailable. Together with `disabled` the
+     * button stays focusable (`aria-disabled` instead of the native attribute), ignores activation
+     * and shows the reason on hover, focus and tap (disabled-states DIS-1…DIS-4). Without
+     * `disabled` it has no effect.
+     */
+    disabledReason?: ReactNode;
+    /**
+     * @figmaProp none — behavioral. Busy: spinner centred over the label (the label stays invisible in the layout, so the width is kept), `aria-busy`, focus kept,
+     * activation ignored (disabled-states DIS-8, submit-buttons SUB-4). The start is announced politely.
+     * Pass a boolean from the first render: the announcement region exists only while `loading` is defined.
+     */
+    loading?: boolean;
+    /**
+     * @figmaProp none — behavioral. Whether a `loading` button keeps the dialog around it open (no Esc,
+     * backdrop, X or Cancel) until it ends; defaults to `true`, the rule for a running save (submit-buttons
+     * SUB-8). Pass `false` for an action that is not a save, such as a search or a lookup.
+     */
+    holdsDialog?: boolean;
+    /** Language of the default busy announcement; defaults to English. */
+    locale?: UiCoreLocale;
+    /** @figmaProp none — behavioral. Announced when `loading` starts; defaults to "In progress" in `locale`. */
+    loadingAnnouncement?: string;
 }
 interface variantTextGrayProps {
     /** @figmaProp Type = textGray→"Quaternary" (transparent bg, text-icon/body #49525f) */
@@ -50,5 +74,5 @@ export type StyledButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> &
  * @param refLink -  ref to component
  * @param dataTest -  data-test tag
  */
-export declare const StyledButton: ({ variant, className, size, children, refLink, startIcon, endIcon, dataTest, error, style: styleProp, ...otherProps }: StyledButtonProps) => JSX.Element;
+export declare const StyledButton: ({ variant, className, size, children, refLink, startIcon, endIcon, dataTest, error, style: styleProp, disabled, disabledReason, loading, holdsDialog, loadingAnnouncement, locale, onClick, ...otherProps }: StyledButtonProps) => JSX.Element;
 export {};

package/dist/src/components/inputs/button/StyledButtonBusy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/navigation/link/StyledLink.d.ts

@@ -10,6 +10,12 @@ export type StyledLinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'onC
     onClick?: (event: MouseEvent<HTMLAnchorElement | HTMLButtonElement>) => void;
     /** @figmaProp State = true→"Disabled" (renders a non-interactive <span>, delta-300) */
     disabled?: boolean;
+    /**
+     * @figmaProp none — behavioral. Why the link is unavailable. With `disabled` the link stays
+     * focusable (`aria-disabled`), does not navigate and shows the reason on hover, focus and tap
+     * (disabled-states DIS-1…DIS-3). Without it a disabled link stays a plain `<span>`.
+     */
+    disabledReason?: ReactNode;
     /** @figmaProp Size = small→"Base" (14/20) | large→"Medium" (16/24); xs (12/20) = none (no DS size) */
     size?: 'small' | 'large' | 'xs';
     /** @figmaProp none — ref */

package/dist/src/components/navigation/menu/StyledMenuItem.d.ts

@@ -12,6 +12,13 @@ export interface StyledMenuItemProps {
     onMouseUp?: (event: MouseEvent<HTMLLIElement>) => void;
     /** @figmaProp State = true→"Disabled" */
     disabled?: boolean;
+    /**
+     * @figmaProp none — behavioral. Why the item is unavailable. With `disabled` the item stays in
+     * arrow-key navigation and shows the reason on hover, focus and tap (disabled-states DIS-1…DIS-3).
+     */
+    disabledReason?: ReactNode;
+    /** @figmaProp none — behavioral. The item's action is running; pair it with `disabled` and a reason. */
+    'aria-busy'?: boolean;
     /** @figmaProp State = true→"Selected" */
     selected?: boolean;
     /** Compact vertical padding (MUI `MenuItem` `dense` parity, DEC-003). */
@@ -36,4 +43,4 @@ export interface StyledMenuItemProps {
  * Native `role="menuitem"` (replaces MUI `MenuItem`). Enter/Space activate; a disabled item stays
  * focusable but non-interactive (MUI parity). Public props preserved (DEC-003). TASK-303.
  */
-export declare const StyledMenuItem: ({ children, onClick, onMouseDown, onMouseUp, disabled, selected, dense, tooltip, className, classes, sx, "data-test": dataTest, "data-testid": dataTestId, value: _value, }: StyledMenuItemProps) => JSX.Element;
+export declare const StyledMenuItem: ({ children, onClick, onMouseDown, onMouseUp, disabled, disabledReason, "aria-busy": ariaBusy, selected, dense, tooltip, className, classes, sx, "data-test": dataTest, "data-testid": dataTestId, value: _value, }: StyledMenuItemProps) => JSX.Element;

package/dist/src/components/navigation/menu/StyledMenuList.d.ts

@@ -13,6 +13,7 @@ export interface StyledMenuListProps {
 }
 /**
  * Keyboard-navigable `role="menu"` list (replaces MUI `MenuList`). Arrow-key / Home / End roving
- * focus over enabled `[role="menuitem"]` children. TASK-303.
+ * focus over every `[role="menuitem"]` child, disabled ones included; opening focuses the first
+ * enabled item. TASK-303.
  */
 export declare const StyledMenuList: ({ children, id, role, className, autoFocus, disablePadding, onClick, onKeyDown, }: StyledMenuListProps) => JSX.Element;

package/dist/src/components/navigation/tabs/StyledTab.d.ts

@@ -12,8 +12,24 @@ export interface StyledTabProps {
     value?: TabValue;
     /** @figmaProp Label (tab content; may include a leading icon) */
     label?: ReactNode;
-    /** @figmaProp State = true→"Disabled" */
+    /**
+     * @figmaProp State = true→"Disabled". Rendered as `aria-disabled`, not native `disabled`: the tab
+     * stays in the arrow-key order so keyboard users can find it (disabled-states DIS-3); a click or
+     * Enter does not select it.
+     */
     disabled?: boolean;
+    /**
+     * @figmaProp none — behavioral. Why the tab is unavailable. With `disabled` the tab stays in
+     * arrow-key navigation and shows the reason on hover, focus and tap (disabled-states DIS-1…DIS-3).
+     */
+    disabledReason?: ReactNode;
+    /**
+     * @figmaProp none — a11y
+     * Tooltip on the tab, opened by hover and keyboard focus and read as the tab's description —
+     * typically why a `disabled` tab is unavailable (disabled-states DIS-1, DIS-2). Falsy renders none.
+     * A `disabledReason` takes its place while the tab is disabled.
+     */
+    tooltip?: ReactNode;
     className?: string;
     sx?: unknown;
     /** @internal Injected by `StyledTabs` so a value-less tab selects by position (MUI parity). */

package/dist/src/forms/submitChanged.d.ts

@@ -3,4 +3,7 @@ export type SubmitChangedPatch<TFieldValues extends FieldValues> = (dirty: Parti
 export interface SubmitChangedOptions {
     touchInvalidFields?: boolean;
 }
+/**
+ * Does not set react-hook-form `formState.isSubmitting`; callers drive the busy state from their own pending flag.
+ */
 export declare function submitChanged<TFieldValues extends FieldValues>(methods: UseFormReturn<TFieldValues>, onPatch: SubmitChangedPatch<TFieldValues>, onInvalid?: () => void, options?: SubmitChangedOptions): Promise<boolean>;

package/dist/src/helpers/focusable.d.ts

@@ -6,3 +6,12 @@ export declare const tabbableWithin: (root: ParentNode) => HTMLElement[];
  * disabled control, which the caller has to decide about.
  */
 export declare const firstTabbable: (root: HTMLElement) => HTMLElement | null;
+/**
+ * The element a description belongs to for `root`: its first focusable element, including a
+ * roving-tabindex item (`tabindex="-1"`, an unselected tab or a menu item) that arrow keys still move
+ * focus to — inside a `tablist` or `menu` the wrapper would be a child those roles do not allow.
+ * Unlike `firstTabbable` it ignores a temporarily unreachable subtree: a reasoned control inside a
+ * collapsed accordion panel (`inert`) or a `display: none` parent is still the element a description
+ * belongs to once the panel opens, and neither state change re-renders the describer.
+ */
+export declare const firstFocusable: (root: HTMLElement) => HTMLElement | null;

package/dist/src/helpers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './cn';
 export * from './omit';
 export * from './prepareForSlot';
+export * from './uiCoreLocale';

package/dist/src/helpers/uiCoreLocale.d.ts

@@ -0,0 +1 @@
+export type UiCoreLocale = 'en' | 'no';

package/dist/src/helpers/warnUnnamedDialog.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Development-only: a `StyledDialog` with no `dialogTitle`, `dialogLabel`, `ariaLabel` or heading in its
+ * content has no accessible name (WCAG 4.1.2, axe `aria-dialog-name`). Silent in production.
+ */
+export declare function warnUnnamedDialog(dataTest: string | undefined): void;

package/dist/src/table/shared-components/StyledMenuItem.d.ts

@@ -1,7 +1,11 @@
 import { MouseEvent, ReactNode } from 'react';
+import { TooltipProps } from '../../components/data-display/tooltip/StyledTooltip';
 export interface StyledMenuItemProps {
     children?: ReactNode;
     disabled?: boolean;
+    /** Why a disabled item can't be used; keeps it reachable by arrow keys and shows the reason. */
+    disabledReason?: ReactNode;
+    reasonPlacement?: TooltipProps['placement'];
     selected?: boolean;
     className?: string;
     classes?: {
@@ -15,4 +19,4 @@ export interface StyledMenuItemProps {
  * Table row-action menu item (replaces MUI `MenuItem`). Native `role="menuitem"`; disabled stays
  * focusable but non-interactive. TASK-404.
  */
-export declare const StyledMenuItem: ({ children, disabled, selected, className, classes, onClick, onMouseDown, onMouseUp, }: StyledMenuItemProps) => JSX.Element;
+export declare const StyledMenuItem: ({ children, disabled, disabledReason, reasonPlacement, selected, className, classes, onClick, onMouseDown, onMouseUp, }: StyledMenuItemProps) => JSX.Element;