@salt-ds/core 1.60.0 → 1.62.0

package/dist-types/rating/Rating.d.ts

@@ -0,0 +1,48 @@
+import { type ChangeEvent, type ComponentPropsWithoutRef } from "react";
+export interface RatingProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    /**
+     * When provided, the component is controlled.
+     */
+    value?: number;
+    /**
+     * Default rating value for uncontrolled mode.
+     * @default 0
+     */
+    defaultValue?: number;
+    /**
+     * Callback function for rating change.
+     * The first parameter is the event, and the second is the selected rating value.
+     */
+    onChange?: (event: ChangeEvent<HTMLInputElement>, value: number) => void;
+    /**
+     * If true, the rating component will be in a read-only state.
+     */
+    readOnly?: boolean;
+    /**
+     * If true, the rating component will be in a disabled state.
+     */
+    disabled?: boolean;
+    /**
+     * Total number of icons displayed.
+     * @default 5
+     */
+    max?: number;
+    /**
+     * Function used to provide a user-friendly name for the current value of the rating. Primarily used by screen readers.
+     */
+    getLabel?: (value: number) => string;
+    /**
+     * Function used to provide a visible label for the rating.
+     */
+    getVisibleLabel?: (value: number, max: number) => string;
+    /**
+     * Position of the label relative to the rating component.
+     * @default "right"
+     */
+    labelPlacement?: "right" | "bottom";
+    /**
+     * The name to be set on each radio button within the group. If not set, then one will be generated for you.
+     */
+    name?: string;
+}
+export declare const Rating: import("react").ForwardRefExoticComponent<RatingProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/rating/RatingItem.d.ts

@@ -0,0 +1,47 @@
+import { type ChangeEvent, type ComponentPropsWithoutRef, type MouseEvent } from "react";
+export interface RatingItemProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * specifies the value of the feedback item.
+     */
+    value: number;
+    /**
+     * To define if the current star is being hovered.
+     */
+    isHovered?: boolean;
+    /**
+     * To specify if the item is selected.
+     */
+    isSelected?: boolean;
+    /**
+     * defines the current selected rating.
+     */
+    currentRating?: number;
+    /**
+     *  callback function when feedback item is hovered.
+     */
+    onMouseEnter: (event: MouseEvent<HTMLInputElement>) => void;
+    /**
+     *  callback function when feedback item is clicked.
+     */
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * If true, the rating item will be in a read-only state.
+     */
+    readOnly?: boolean;
+    /**
+     * If true, the rating item will be in a disabled state.
+     */
+    disabled?: boolean;
+    /**
+     * Indicates whether the current rating item is in an active state.
+     * An active state typically means that the item is visually highlighted
+     * or styled differently to indicate that it is part of the current selection
+     * or interaction (e.g., hover or focus).
+     */
+    isUnselecting?: boolean;
+    /**
+     * Name of the radio group
+     */
+    name?: string;
+}
+export declare const RatingItem: import("react").ForwardRefExoticComponent<RatingItemProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist-types/rating/index.d.ts

@@ -0,0 +1 @@
+export * from "./Rating";

package/dist-types/semantic-icon-provider/SemanticIconProvider.d.ts

@@ -1,34 +1,36 @@
 import { type ElementType, type ReactNode } from "react";
 export interface SemanticIconMap {
-    ExpandIcon: ElementType;
-    CollapseIcon: ElementType;
-    ExpandGroupIcon: ElementType;
+    ActiveIcon: ElementType;
+    CalendarIcon: ElementType;
+    CloseIcon: ElementType;
     CollapseGroupIcon: ElementType;
-    NextIcon: ElementType;
-    PreviousIcon: ElementType;
-    IncreaseIcon: ElementType;
+    CollapseIcon: ElementType;
+    CollapseLeftIcon: ElementType;
+    CollapseRightIcon: ElementType;
+    CompletedIcon: ElementType;
     DecreaseIcon: ElementType;
-    UploadIcon: ElementType;
     ErrorIcon: ElementType;
-    SuccessIcon: ElementType;
+    ErrorStatusAdornment: ElementType;
+    ExpandGroupIcon: ElementType;
+    ExpandIcon: ElementType;
+    ExternalIcon: ElementType;
+    IncreaseIcon: ElementType;
     InfoIcon: ElementType;
-    WarningIcon: ElementType;
+    InProgressIcon: ElementType;
+    LockedIcon: ElementType;
+    NextIcon: ElementType;
     OverflowIcon: ElementType;
-    UserIcon: ElementType;
-    CalendarIcon: ElementType;
-    CloseIcon: ElementType;
-    ExternalIcon: ElementType;
     PendingIcon: ElementType;
-    ActiveIcon: ElementType;
-    CompletedIcon: ElementType;
-    LockedIcon: ElementType;
-    InProgressIcon: ElementType;
+    PreviousIcon: ElementType;
     RatingIcon: ElementType;
     RatingSelectedIcon: ElementType;
     RatingUnselectingIcon: ElementType;
-    ErrorStatusAdornment: ElementType;
-    WarningStatusAdornment: ElementType;
+    SuccessIcon: ElementType;
     SuccessStatusAdornment: ElementType;
+    UploadIcon: ElementType;
+    UserIcon: ElementType;
+    WarningIcon: ElementType;
+    WarningStatusAdornment: ElementType;
 }
 export interface SemanticIconProviderProps {
     /**

package/dist-types/side-panel/SidePanel.d.ts

@@ -0,0 +1,26 @@
+import { type ComponentPropsWithRef, type RefObject } from "react";
+export interface SidePanelProps extends ComponentPropsWithRef<"div"> {
+    /**
+     * Disable the panel's own open/close animation.
+     * Set to `true` when the parent controls sizing and animation (e.g. inside a splitter).
+     * @default false
+     */
+    disableAnimation?: boolean;
+    /**
+     * Edge the panel is anchored to; controls animation direction and divider side.
+     * @default "right"
+     */
+    position?: "right" | "left";
+    /**
+     * Which element receives focus when the panel opens.
+     * Pass a number for the tabbable element index (0 = first), or a ref to a specific element.
+     * Defaults to the first tabbable element inside the panel (close button if present).
+     */
+    initialFocus?: number | RefObject<HTMLElement | null>;
+    /**
+     * The background color palette. Options are 'primary', 'secondary', 'tertiary' and 'none'.
+     * @default "primary"
+     */
+    variant?: "primary" | "secondary" | "tertiary" | "none";
+}
+export declare const SidePanel: import("react").ForwardRefExoticComponent<Omit<SidePanelProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/side-panel/SidePanelCloseButton.d.ts

@@ -0,0 +1,2 @@
+import { type ButtonProps } from "../button";
+export declare const SidePanelCloseButton: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/side-panel/SidePanelContent.d.ts

@@ -0,0 +1,5 @@
+import { type ComponentPropsWithRef } from "react";
+export type SidePanelContentProps = ComponentPropsWithRef<"div">;
+export declare const SidePanelContent: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/side-panel/SidePanelHeader.d.ts

@@ -0,0 +1,5 @@
+import { type ComponentPropsWithRef } from "react";
+export type SidePanelHeaderProps = ComponentPropsWithRef<"div">;
+export declare const SidePanelHeader: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/side-panel/SidePanelProvider.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+export interface SidePanelProviderProps {
+    /**
+     * Whether the panel is open.
+     */
+    open?: boolean;
+    /**
+     * Default open state when initially rendered.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Callback when open state changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * SidePanelProvider children, should include SidePanel and SidePanelTrigger.
+     */
+    children: ReactNode;
+}
+export declare function SidePanelProvider(props: SidePanelProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist-types/side-panel/SidePanelTitle.d.ts

@@ -0,0 +1,3 @@
+import { type TextProps } from "../text";
+export type SidePanelTitleProps = TextProps<"div">;
+export declare const SidePanelTitle: import("react").ForwardRefExoticComponent<Omit<SidePanelTitleProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/side-panel/SidePanelTrigger.d.ts

@@ -0,0 +1,3 @@
+import { type ComponentPropsWithoutRef } from "react";
+export type SidePanelTriggerProps = ComponentPropsWithoutRef<"button">;
+export declare const SidePanelTrigger: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/side-panel/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./SidePanel";
+export * from "./SidePanelCloseButton";
+export * from "./SidePanelContent";
+export * from "./SidePanelHeader";
+export * from "./SidePanelProvider";
+export * from "./SidePanelTitle";
+export * from "./SidePanelTrigger";
+export * from "./useSidePanel";

package/dist-types/side-panel/internal/SidePanelContext.d.ts

@@ -0,0 +1,52 @@
+import type { FloatingRootContext } from "@floating-ui/react";
+import { type Dispatch, type SetStateAction } from "react";
+export interface SidePanelContextValue {
+    /**
+     * Whether the side panel is currently open.
+     */
+    openState: boolean;
+    /**
+     * The floating-ui root context shared between the trigger and the panel.
+     * Coordinates interactions (click, dismiss, role) across both elements.
+     */
+    floatingRootContext: FloatingRootContext;
+    /**
+     * Ref setter for the panel element.
+     * Registers the panel DOM node with floating-ui.
+     */
+    setFloating: Dispatch<SetStateAction<HTMLDivElement | null>>;
+    /**
+     * Ref setter for the reference (trigger) element.
+     * Registers the trigger DOM node with floating-ui for focus return.
+     */
+    setReference: Dispatch<SetStateAction<HTMLElement | null>>;
+    /**
+     * Sets the open state of the panel.
+     * Called by the close button in SidePanelHeader, or any consumer that needs to close the panel.
+     */
+    setOpen: (open: boolean) => void;
+    /**
+     * Side panel id used for aria-controls on the trigger.
+     */
+    panelId?: string;
+    /**
+     * Registers or clears the side panel id used for aria-controls/id linkage.
+     */
+    setPanelId: Dispatch<SetStateAction<string | undefined>>;
+    /**
+     * The auto-generated id placed on SidePanelTitle.
+     * Used for aria-labelledby on the panel region and the scrollable body.
+     */
+    titleId?: string;
+    /**
+     * Registers the title id from SidePanelTitle back to the context
+     * so that SidePanel and SidePanelContent can use it for aria-labelledby.
+     */
+    setTitleId: Dispatch<SetStateAction<string | undefined>>;
+    /**
+     * Edge the panel is anchored to. Set by SidePanel for its own subtree.
+     */
+    position?: "right" | "left";
+}
+export declare const SidePanelContext: import("react").Context<SidePanelContextValue>;
+export declare function useSidePanelContext(): SidePanelContextValue;

package/dist-types/side-panel/internal/index.d.ts

@@ -0,0 +1,3 @@
+export { SidePanelContext, type SidePanelContextValue, useSidePanelContext, } from "./SidePanelContext";
+export * from "./useIsScrollable";
+export * from "./useSidePanelTabOrder";

package/dist-types/side-panel/internal/useIsScrollable.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from "react";
+export declare function useIsScrollable(ref: RefObject<HTMLElement>): boolean;

package/dist-types/side-panel/internal/useSidePanelTabOrder.d.ts

@@ -0,0 +1,7 @@
+interface UseSidePanelTabOrderProps {
+    floating: HTMLElement | null;
+    open: boolean;
+    reference: HTMLElement | null;
+}
+export declare function useSidePanelTabOrder(props: UseSidePanelTabOrderProps): void;
+export {};

package/dist-types/side-panel/useSidePanel.d.ts

@@ -0,0 +1,58 @@
+import type { ComponentPropsWithoutRef, MouseEvent, MutableRefObject, RefCallback } from "react";
+export interface SidePanelTriggerExtraProps {
+    /**
+     * Optional ref to forward alongside the focus-return registration.
+     */
+    ref?: RefCallback<HTMLElement | null> | MutableRefObject<HTMLElement | null> | null;
+    /**
+     * Click handler. Runs before the built-in toggle so consumers can
+     * preventDefault to skip the toggle.
+     */
+    onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
+}
+export type SidePanelTriggerPropsResult = ComponentPropsWithoutRef<"button"> & {
+    "aria-expanded": boolean;
+    "aria-controls": string | undefined;
+    ref: RefCallback<HTMLElement | null>;
+};
+export interface SidePanelValue {
+    /**
+     * Whether the side panel is currently open.
+     */
+    openState: boolean;
+    /**
+     * Sets the open state of the panel.
+     */
+    setOpen: (open: boolean) => void;
+    /**
+     * Props getter for a trigger element outside of `SidePanelTrigger`.
+     * Returns `aria-expanded`, `aria-controls`, a `ref` (for focus-return),
+     * and an `onClick` that toggles the panel.
+     *
+     * Spread the result onto a Button to get full trigger behavior:
+     * ```tsx
+     * <Button {...getTriggerProps()}>Toggle panel</Button>
+     * ```
+     *
+     * You can pass additional props which are merged in. If you provide your
+     * own `onClick`, it runs before the built-in toggle. If you provide your
+     * own `ref`, it is forwarded alongside the internal focus-return ref.
+     *
+     * For multi-trigger scenarios (e.g. table rows), use `setTriggerRef` and
+     * manage ARIA attributes yourself instead.
+     */
+    getTriggerProps: (userProps?: SidePanelTriggerExtraProps) => SidePanelTriggerPropsResult;
+    /**
+     * Registers the element that should receive focus when the panel closes.
+     * Use this in multi-trigger scenarios (e.g. table rows) where each trigger
+     * needs explicit control over which element is the reference. Pass `null`
+     * to clear the previously-registered trigger.
+     */
+    setTriggerRef: (element: HTMLElement | null) => void;
+    /**
+     * The panel's DOM id. Use this for `aria-controls` in multi-trigger
+     * scenarios where you manage ARIA attributes yourself.
+     */
+    panelId: string | undefined;
+}
+export declare function useSidePanel(): SidePanelValue;

package/dist-types/tabs/Tab.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentPropsWithoutRef } from "react";
+export interface TabProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * If `true`, the tab will be disabled.
+     */
+    disabled?: boolean;
+    /**
+     * The value of the tab. This must be unique within a `Tabs` instance.
+     */
+    value: string;
+}
+export declare const Tab: import("react").ForwardRefExoticComponent<TabProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tabs/TabAction.d.ts

@@ -0,0 +1,4 @@
+import { type ButtonProps } from "../button";
+export interface TabActionProps extends ButtonProps {
+}
+export declare const TabAction: import("react").ForwardRefExoticComponent<TabActionProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/tabs/TabBar.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentPropsWithRef } from "react";
+export interface TabBarProps extends ComponentPropsWithRef<"div"> {
+    /**
+     * Styling variant with a bottom separator. Defaults to false
+     */
+    divider?: boolean;
+    /**
+     * Styling variant with left and right padding. Defaults to false
+     */
+    inset?: boolean;
+}
+export declare const TabBar: import("react").ForwardRefExoticComponent<Omit<TabBarProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tabs/TabList.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentPropsWithoutRef } from "react";
+export interface TabListProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    /**
+     * Styling active color variant. Defaults to "primary".
+     */
+    activeColor?: "primary" | "secondary" | "tertiary";
+    /**
+     * The appearance of the tabs. Defaults to "bordered".
+     */
+    appearance?: "bordered" | "transparent";
+}
+export declare const TabList: import("react").ForwardRefExoticComponent<TabListProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tabs/TabPanel.d.ts

@@ -0,0 +1,9 @@
+import { type ComponentPropsWithoutRef } from "react";
+export interface TabPanelProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * The value of the panel. This should map to the corresponding tab and must
+     * be unique within a `Tabs` instance.
+     */
+    value: string;
+}
+export declare const TabPanel: import("react").ForwardRefExoticComponent<TabPanelProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tabs/TabTrigger.d.ts

@@ -0,0 +1,4 @@
+import { type ComponentPropsWithoutRef } from "react";
+export interface TabTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "id"> {
+}
+export declare const TabTrigger: import("react").ForwardRefExoticComponent<TabTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/tabs/Tabs.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentPropsWithoutRef, type ReactNode, type SyntheticEvent } from "react";
+export interface TabsProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    children?: ReactNode;
+    /**
+     * The default value. Use when the component is not controlled.
+     */
+    defaultValue?: string;
+    /**
+     * The value. Use when the component is controlled.
+     */
+    value?: string;
+    /**
+     * Callback fired when the selection changes.
+     * The event will be null when selection is moved automatically, such as when
+     * the currently selected tab is removed and the next available tab is
+     * selected.
+     */
+    onChange?: (event: SyntheticEvent | null, value: string) => void;
+}
+export declare const Tabs: import("react").ForwardRefExoticComponent<TabsProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tabs/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Tab";
+export * from "./TabAction";
+export * from "./TabBar";
+export * from "./TabList";
+export * from "./TabPanel";
+export * from "./Tabs";
+export * from "./TabTrigger";

package/dist-types/tabs/internal/contexts/TabContext.d.ts

@@ -0,0 +1,12 @@
+interface TabContextValue {
+    tabId?: string;
+    focused: boolean;
+    selected: boolean;
+    value: string;
+    disabled: boolean;
+    actions: string[];
+    registerAction: (id: string) => () => void;
+}
+export declare const TabContext: import("react").Context<TabContextValue>;
+export declare function useTab(): TabContextValue;
+export {};

package/dist-types/tabs/internal/contexts/TabListLayoutContext.d.ts

@@ -0,0 +1,9 @@
+export type TabSlotLocation = "hidden" | "main" | "overflow";
+export interface TabListLayoutContextValue {
+    getLocation: (value: string) => TabSlotLocation;
+    overflowActiveValue: string | null;
+    setOverflowActiveValue: (value: string | null) => void;
+    moveOverflowFocus: (key: "ArrowDown" | "ArrowUp" | "Home" | "End", value: string) => boolean;
+}
+export declare const TabListLayoutContext: import("react").Context<TabListLayoutContextValue | null>;
+export declare function useTabListLayout(): TabListLayoutContextValue | null;

package/dist-types/tabs/internal/contexts/TabSlotRegistryContext.d.ts

@@ -0,0 +1,5 @@
+export interface TabSlotRegistryContextValue {
+    registerSlot: (slotId: string, element: HTMLDivElement | null) => void;
+}
+export declare const TabSlotRegistryContext: import("react").Context<TabSlotRegistryContextValue | null>;
+export declare function useTabSlotRegistry(): TabSlotRegistryContextValue | null;

package/dist-types/tabs/internal/contexts/TabsContext.d.ts

@@ -0,0 +1,43 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction, type SyntheticEvent } from "react";
+import type { useCollection } from "../registry/useCollection";
+export interface Item {
+    id: string;
+    value: string;
+    element: HTMLElement | null;
+    location?: "hidden" | "main" | "overflow";
+    order?: number;
+}
+export interface RenderedTab {
+    host: HTMLDivElement;
+    id: string;
+    marker: HTMLElement | null;
+    root: HTMLElement | null;
+    trigger: HTMLButtonElement | null;
+    value: string;
+    width: number;
+}
+export type TabsRenderMode = "inline" | "portal";
+export interface TabsContextValue extends Omit<ReturnType<typeof useCollection>, "registerItem" | "updateItem"> {
+    renderMode: TabsRenderMode;
+    registerBootstrapTab: (value: string) => () => void;
+    setBootstrapTabReady: (value: string, ready: boolean) => void;
+    setBootstrapOverflowReady: (ready: boolean) => void;
+    registerTab: (item: Item) => () => void;
+    updateTab: (id: string, updates: Partial<Omit<Item, "id" | "value">>) => void;
+    registerRenderedTab: (tab: RenderedTab) => () => void;
+    updateRenderedTab: (value: string, updates: Partial<Omit<RenderedTab, "value">>) => void;
+    getRenderedTab: (value: string) => RenderedTab | undefined;
+    getRenderedTabOrder: (value: string) => number;
+    renderedTabs: RenderedTab[];
+    registerPanel: (id: string, value: string) => () => void;
+    getPanelId: (value: string) => string | undefined;
+    getTabId: (value: string) => string | undefined;
+    selected?: string;
+    setSelected: (event: SyntheticEvent | null, value: string, source?: "main" | "overflow") => void;
+    activeTab: MutableRefObject<Pick<Item, "id" | "value"> | undefined>;
+    selectionFromOverflowValueRef: MutableRefObject<string | null>;
+    menuOpen: boolean;
+    setMenuOpen: Dispatch<SetStateAction<boolean>>;
+}
+export declare const TabsContext: import("react").Context<TabsContextValue>;
+export declare function useTabs(): TabsContextValue;

package/dist-types/tabs/internal/hooks/useFocusWithRetry.d.ts

@@ -0,0 +1,9 @@
+interface UseFocusWithRetryArgs {
+    maxAttempts?: number;
+    targetWindow: Window | null | undefined;
+}
+export declare function useFocusWithRetry({ maxAttempts, targetWindow, }: UseFocusWithRetryArgs): {
+    cancelScheduledFocus: () => void;
+    focusElementWithRetry: (getElement: () => HTMLElement | null | undefined) => void;
+};
+export {};

package/dist-types/tabs/internal/hooks/useTabListRecovery.d.ts

@@ -0,0 +1,12 @@
+import { type MutableRefObject, type RefObject } from "react";
+interface UseTabListRecoveryArgs {
+    removalVersion: number;
+    targetWindow: Window | null | undefined;
+    tabstripRef: RefObject<HTMLDivElement | null>;
+    overflowListRef: RefObject<HTMLDivElement | null>;
+    handleTabRemoval: () => void;
+    pendingRemovalRecoveryRef: MutableRefObject<boolean>;
+    pendingRemovalRecoveryRetriesRef: MutableRefObject<number>;
+}
+export declare function useTabListRecovery({ removalVersion, targetWindow, tabstripRef, overflowListRef, handleTabRemoval, pendingRemovalRecoveryRef, pendingRemovalRecoveryRetriesRef, }: UseTabListRecoveryArgs): void;
+export {};

package/dist-types/tabs/internal/hooks/useTabRemovalHandler.d.ts

@@ -0,0 +1,32 @@
+import { type MutableRefObject, type RefObject } from "react";
+import type { Item, TabsContextValue } from "../contexts/TabsContext";
+interface RemovedItem {
+    id: string;
+    value: string;
+    staleIndex?: number;
+}
+interface UseTabRemovalHandlerArgs {
+    activeTab: MutableRefObject<Pick<Item, "id" | "value"> | undefined>;
+    focusElementWithRetry: (getElement: () => HTMLElement | null | undefined) => void;
+    getFirst: TabsContextValue["getFirst"];
+    getIndex: TabsContextValue["getIndex"];
+    getLast: TabsContextValue["getLast"];
+    getRemovedItems: () => Map<string, RemovedItem>;
+    getRenderedTab: TabsContextValue["getRenderedTab"];
+    getSelectedTabElement: () => HTMLElement | null | undefined;
+    item: TabsContextValue["item"];
+    itemAt: TabsContextValue["itemAt"];
+    maxRetryAttempts: number;
+    menuOpen: boolean;
+    overflowButtonRef: RefObject<HTMLButtonElement | null>;
+    overflowListRef: RefObject<HTMLDivElement | null>;
+    pendingRemovalRecoveryRef: MutableRefObject<boolean>;
+    pendingRemovalRecoveryRetriesRef: MutableRefObject<number>;
+    removalRecoveryRafRef: MutableRefObject<number | null>;
+    selected?: string;
+    setSelected: TabsContextValue["setSelected"];
+    tabstripRef: RefObject<HTMLDivElement | null>;
+    targetWindow: Window | null | undefined;
+}
+export declare function useTabRemovalHandler({ activeTab, focusElementWithRetry, getFirst, getIndex, getLast, getRemovedItems, getRenderedTab, getSelectedTabElement, item, itemAt, maxRetryAttempts, menuOpen, overflowButtonRef, overflowListRef, pendingRemovalRecoveryRef, pendingRemovalRecoveryRetriesRef, removalRecoveryRafRef, selected, setSelected, tabstripRef, targetWindow, }: UseTabRemovalHandlerArgs): () => void;
+export {};

package/dist-types/tabs/internal/hooks/useTabSelectionFocus.d.ts

@@ -0,0 +1,15 @@
+import type { MutableRefObject } from "react";
+import type { TabsContextValue } from "../contexts/TabsContext";
+interface UseTabSelectionFocusArgs {
+    announce: (message: string, timeout?: number) => void;
+    focusElementWithRetry: (getElement: () => HTMLElement | null | undefined) => void;
+    getRenderedTab: TabsContextValue["getRenderedTab"];
+    getSelectedTabElement: () => HTMLElement | null | undefined;
+    menuOpen: boolean;
+    resolvedOverflowActiveValue: string | null;
+    selected?: string;
+    selectionFromOverflowValueRef: MutableRefObject<string | null>;
+    targetWindow: Window | null | undefined;
+}
+export declare function useTabSelectionFocus({ announce, focusElementWithRetry, getRenderedTab, getSelectedTabElement, menuOpen, resolvedOverflowActiveValue, selected, selectionFromOverflowValueRef, targetWindow, }: UseTabSelectionFocusArgs): void;
+export {};

package/dist-types/tabs/internal/overflow/TabOverflowList.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentPropsWithoutRef, type Dispatch, type Ref, type SetStateAction } from "react";
+interface TabOverflowListProps extends ComponentPropsWithoutRef<"button"> {
+    buttonRef?: Ref<HTMLButtonElement>;
+    hiddenValues: string[];
+    open: boolean;
+    setOpen: Dispatch<SetStateAction<boolean>>;
+    order: number;
+}
+export declare const TabOverflowList: import("react").ForwardRefExoticComponent<TabOverflowListProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist-types/tabs/internal/overflow/TabSlot.d.ts

@@ -0,0 +1,6 @@
+import { type ComponentPropsWithoutRef } from "react";
+export interface TabSlotProps extends ComponentPropsWithoutRef<"div"> {
+    slotId: string;
+    value: string;
+}
+export declare function TabSlot({ slotId, value, ...rest }: TabSlotProps): import("react/jsx-runtime").JSX.Element;