@fabio.caffarello/react-design-system 1.24.0 → 2.0.0

package/dist/ui/components/SideNavbar/components/Sidebar/SidebarSlot.d.ts

@@ -37,4 +37,4 @@ export interface SidebarSlotProps {
  * </SideNavbar>
  * ```
  */
-export declare function SidebarSlot({ id, children }: SidebarSlotProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function SidebarSlot({ id, children }: SidebarSlotProps): import("react").JSX.Element | null;

package/dist/ui/components/SideNavbar/components/Sidebar/SidebarSlotContent.d.ts

@@ -26,4 +26,4 @@ export interface SidebarSlotContentProps {
  * </SideNavbar.Sidebar>
  * ```
  */
-export declare function SidebarSlotContent({ fallback, }: SidebarSlotContentProps): import("react/jsx-runtime").JSX.Element;
+export declare function SidebarSlotContent({ fallback, }: SidebarSlotContentProps): import("react").JSX.Element;

package/dist/ui/components/SideNavbar/hooks/useSideNavbar.d.ts

@@ -29,7 +29,7 @@ export { useSideNavbarContent } from "./useSideNavbarContent";
  * ```
  */
 export declare function useSideNavbarCombined(): {
-    theme: any;
-    config: any;
-    state: any;
+    theme: import("..").SideNavbarThemeContextValue;
+    config: import("..").SideNavbarConfigContextValue;
+    state: import("..").SideNavbarStateContextValue;
 };

package/dist/ui/components/SideNavbar/providers/SideNavbarConfigProvider.d.ts

@@ -14,5 +14,5 @@ import type { SideNavbarConfigProviderProps } from "../types";
  * </SideNavbarConfigProvider>
  * ```
  */
-export declare function SideNavbarConfigProvider({ children, mode, resizable, minWidth, maxWidth, snapPoints, responsive, mobileBreakpoint, mobileVariant, overlayBackdrop, persistState, persistWidth, storageKey, keyboardShortcut, enableKeyboardShortcut, }: SideNavbarConfigProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SideNavbarConfigProvider({ children, mode, resizable, minWidth, maxWidth, snapPoints, responsive, mobileBreakpoint, mobileVariant, overlayBackdrop, persistState, persistWidth, storageKey, keyboardShortcut, enableKeyboardShortcut, }: SideNavbarConfigProviderProps): import("react").JSX.Element;
 export default SideNavbarConfigProvider;

package/dist/ui/components/SideNavbar/providers/SideNavbarProvider.d.ts

@@ -22,5 +22,5 @@ import type { SideNavbarProviderProps } from "../types";
  * </SideNavbarProvider>
  * ```
  */
-export declare function SideNavbarProvider({ children, variant, navigationWidth, contentWidth, animationDuration, animationEasing, mode, resizable, minWidth, maxWidth, snapPoints, responsive, mobileBreakpoint, mobileVariant, overlayBackdrop, persistState, persistWidth, storageKey, keyboardShortcut, enableKeyboardShortcut, defaultCollapsed, collapsed, onCollapseChange, onWidthChange, onMobileChange, exclusiveGroups, }: SideNavbarProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SideNavbarProvider({ children, variant, navigationWidth, contentWidth, animationDuration, animationEasing, mode, resizable, minWidth, maxWidth, snapPoints, responsive, mobileBreakpoint, mobileVariant, overlayBackdrop, persistState, persistWidth, storageKey, keyboardShortcut, enableKeyboardShortcut, defaultCollapsed, collapsed, onCollapseChange, onWidthChange, onMobileChange, exclusiveGroups, }: SideNavbarProviderProps): import("react").JSX.Element;
 export default SideNavbarProvider;

package/dist/ui/components/SideNavbar/providers/SideNavbarStateProvider.d.ts

@@ -18,5 +18,5 @@ import type { SideNavbarStateProviderProps } from "../types";
  * </SideNavbarThemeProvider>
  * ```
  */
-export declare function SideNavbarStateProvider({ children, defaultCollapsed, collapsed: controlledCollapsed, onCollapseChange, onWidthChange, onMobileChange, exclusiveGroups, }: SideNavbarStateProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SideNavbarStateProvider({ children, defaultCollapsed, collapsed: controlledCollapsed, onCollapseChange, onWidthChange, onMobileChange, exclusiveGroups, }: SideNavbarStateProviderProps): import("react").JSX.Element;
 export default SideNavbarStateProvider;

package/dist/ui/components/SideNavbar/providers/SideNavbarThemeProvider.d.ts

@@ -16,5 +16,5 @@ import type { SideNavbarThemeProviderProps } from "../types";
  * </SideNavbarThemeProvider>
  * ```
  */
-export declare function SideNavbarThemeProvider({ children, variant, navigationWidth, contentWidth, animationDuration, animationEasing, }: SideNavbarThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SideNavbarThemeProvider({ children, variant, navigationWidth, contentWidth, animationDuration, animationEasing, }: SideNavbarThemeProviderProps): import("react").JSX.Element;
 export default SideNavbarThemeProvider;

package/dist/ui/components/SideNavbar/providers/SidebarSlotProvider.d.ts

@@ -31,4 +31,4 @@ import type { SidebarSlotProviderProps } from "../types";
  * </SideNavbar>
  * ```
  */
-export declare function SidebarSlotProvider({ children, defaultSlot, }: SidebarSlotProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function SidebarSlotProvider({ children, defaultSlot, }: SidebarSlotProviderProps): import("react").JSX.Element;

package/dist/ui/components/SideNavbar/types/index.d.ts

@@ -395,9 +395,37 @@ export interface NavbarItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonEle
  * Navbar props with expanded mode and label support (defined below)
  */
 export interface NavbarProps extends HTMLAttributes<HTMLElement> {
-    /** Whether to show the main toggle button (at top-right of navbar) */
+    /**
+     * Per-Navbar override for the SideNavbar's main toggle button's
+     * visibility. When set, takes precedence over the root SideNavbar's
+     * `showToggle` prop. The toggle continues to render at the `<aside>`
+     * level (same DOM position as the default global toggle); only its
+     * visibility changes.
+     *
+     * Resolution is render-driven and SSR-safe — the value applies on
+     * the first commit without effects.
+     *
+     * Override is a single-Navbar feature. If multiple
+     * `<SideNavbar.Navbar>` children set overrides simultaneously, the
+     * first in tree order wins and the others are ignored — dev mode
+     * warns when this happens (mirrors React's duplicate-key warning).
+     *
+     * Only DIRECT `<SideNavbar.Navbar>` children are inspected. A Navbar
+     * wrapped in another element (e.g. inside a `<div>` or any custom
+     * wrapper) won't have its override applied — dev mode warns when it
+     * detects this one-level-deep miswiring.
+     */
     showMainToggle?: boolean;
-    /** Position of the main toggle button */
+    /**
+     * Per-Navbar override for the SideNavbar's main toggle button's
+     * position. When set, takes precedence over the root SideNavbar's
+     * `togglePosition` prop. The toggle continues to render at the
+     * `<aside>` level; only the position value changes.
+     *
+     * See `showMainToggle` for the resolution semantics, the
+     * multi-Navbar conflict policy, and the direct-children scope
+     * (with dev-mode warning when a wrapper hides a Navbar override).
+     */
     mainTogglePosition?: SideNavbarTogglePosition;
     /** Whether to show the internal toggle button (inside navbar) */
     showToggle?: boolean;
@@ -434,7 +462,7 @@ export interface SidebarContextValue {
     /** Whether viewport is mobile */
     isMobile: boolean;
     /** Reference to sidebar element */
-    sidebarRef: React.RefObject<HTMLElement | null>;
+    sidebarRef: React.RefObject<HTMLDivElement | null>;
     /** Current scroll position */
     scrollPosition: number;
     /** Set scroll position */

package/dist/ui/components/Stepper/Stepper.d.ts

@@ -37,4 +37,4 @@ export interface StepperProps {
  * />
  * ```
  */
-export default function Stepper({ steps, currentStep: controlledCurrentStep, defaultCurrentStep, onStepChange, onComplete, allowNavigation, showStepNumbers, orientation, className, }: StepperProps): import("react/jsx-runtime").JSX.Element;
+export default function Stepper({ steps, currentStep: controlledCurrentStep, defaultCurrentStep, onStepChange, onComplete, allowNavigation, showStepNumbers, orientation, className, }: StepperProps): import("react").JSX.Element;

package/dist/ui/components/Table/Table.d.ts

@@ -88,7 +88,7 @@ type TableProps<T extends Record<string, unknown> = Record<string, unknown>> = S
  * </Table>
  * ```
  */
-declare function TableComponent<T = unknown>(props: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function TableComponent<T extends Record<string, unknown> = Record<string, unknown>>(props: TableProps<T>): import("react").JSX.Element;
 declare namespace TableComponent {
     var Header: typeof TableHeader;
     var HeaderRow: typeof TableHeaderRow;

package/dist/ui/components/Table/TableActions/TableActions.d.ts

@@ -28,4 +28,4 @@ export interface TableActionsProps<T extends Record<string, unknown> = Record<st
  * />
  * ```
  */
-export default function TableActions<T extends Record<string, unknown> = Record<string, unknown>>({ actions, row, align, className, ...props }: TableActionsProps<T>): import("react/jsx-runtime").JSX.Element;
+export default function TableActions<T extends Record<string, unknown> = Record<string, unknown>>({ actions, row, align, className, ...props }: TableActionsProps<T>): import("react").JSX.Element;

package/dist/ui/components/Table/TableActions.d.ts

@@ -10,4 +10,4 @@ export interface TableActionsProps<T extends Record<string, unknown> = Record<st
  * Uses actions configuration from Table context.
  * Must be used within a Table component.
  */
-export default function TableActions<T extends Record<string, unknown> = Record<string, unknown>>({ row, align, className, ...props }: TableActionsProps<T>): import("react/jsx-runtime").JSX.Element | null;
+export default function TableActions<T extends Record<string, unknown> = Record<string, unknown>>({ row, align, className, ...props }: TableActionsProps<T>): import("react").JSX.Element | null;

package/dist/ui/components/Table/TableBody.d.ts

@@ -1,4 +1,4 @@
-import { type HTMLAttributes, ReactNode } from "react";
+import { type HTMLAttributes, type ReactNode } from "react";
 export interface TableBodyProps<T extends Record<string, unknown> = Record<string, unknown>> extends Omit<HTMLAttributes<HTMLTableSectionElement>, "children"> {
     children?: (row: T, index: number) => ReactNode;
     className?: string;
@@ -10,4 +10,4 @@ export interface TableBodyProps<T extends Record<string, unknown> = Record<strin
  * Can render loading skeleton, empty state, or data rows.
  * Must be used within a Table component.
  */
-export default function TableBody({ children, className, ...props }: TableBodyProps): import("react/jsx-runtime").JSX.Element;
+export default function TableBody({ children, className, ...props }: TableBodyProps): import("react").JSX.Element;

package/dist/ui/components/Table/TableCell.d.ts

@@ -11,4 +11,4 @@ export interface TableCellProps<T = unknown> extends HTMLAttributes<HTMLTableCel
  * Uses column.render if available, otherwise renders the raw value.
  * Must be used within a Table component.
  */
-export default function TableCell<T extends Record<string, unknown> = Record<string, unknown>>({ column, row, className, ...props }: TableCellProps<T>): import("react/jsx-runtime").JSX.Element;
+export default function TableCell<T extends Record<string, unknown> = Record<string, unknown>>({ column, row, className, ...props }: TableCellProps<T>): import("react").JSX.Element;

package/dist/ui/components/Table/TableContext.d.ts

@@ -39,6 +39,11 @@ export interface TableContextValue<T extends Record<string, unknown> = Record<st
     resizable?: boolean;
     columnWidths?: Record<string, number>;
     virtualScrolling?: boolean;
+    virtualScrollingOptions?: {
+        itemHeight?: number;
+        containerHeight?: number;
+        overscan?: number;
+    };
     emptyMessage?: string;
     emptyStateTitle?: string;
     emptyStateMessage?: string;
@@ -61,7 +66,21 @@ export interface TableContextValue<T extends Record<string, unknown> = Record<st
     onRowClick?: (row: T) => void;
     onColumnResize?: (columnKey: string, width: number) => void;
 }
-declare const TableContext: import("react").Context<TableContextValue<Record<string, unknown>> | undefined>;
+/**
+ * Raw React Context object. Exposed so `useContextSelector(TableContext, …)`
+ * keeps working (see hooks/useContextSelector.ts, which cites Table as
+ * its canonical selector consumer). Prefer the typed hooks below for
+ * direct reads.
+ */
+export declare const TableContext: import("react").Context<TableContextValue<Record<string, unknown>> | undefined>;
+/**
+ * Internal Provider — consumed by `TableProvider.tsx` only. Not
+ * re-exported from `Table/index.ts`; keeps the public surface unchanged.
+ */
+export declare const TableContextProvider: <TSpecific = TableContextValue<Record<string, unknown>>>(props: {
+    value: TSpecific;
+    children: ReactNode;
+}) => import("react").JSX.Element;
 /**
  * Hook to access Table context
  *
@@ -72,4 +91,3 @@ export declare function useTableContext<T extends Record<string, unknown> = Reco
  * Hook to access Table context (optional, returns undefined if not in Table)
  */
 export declare function useTableContextOptional<T extends Record<string, unknown> = Record<string, unknown>>(): TableContextValue<T> | undefined;
-export { TableContext };

package/dist/ui/components/Table/TableEmptyState.d.ts

@@ -7,4 +7,4 @@ export type TableEmptyStateProps = HTMLAttributes<HTMLDivElement>;
  * Uses empty state configuration from Table context.
  * Must be used within a Table component.
  */
-export default function TableEmptyState({ className, ...props }: TableEmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export default function TableEmptyState({ className, ...props }: TableEmptyStateProps): import("react").JSX.Element;

package/dist/ui/components/Table/TableFilters/TableFilters.d.ts

@@ -34,4 +34,4 @@ export interface TableFiltersProps extends HTMLAttributes<HTMLDivElement> {
  * />
  * ```
  */
-export default function TableFilters({ filters, onFilter, initialValues, showClearAll, className, ...props }: TableFiltersProps): import("react/jsx-runtime").JSX.Element;
+export default function TableFilters({ filters, onFilter, initialValues, showClearAll, className, ...props }: TableFiltersProps): import("react").JSX.Element;

package/dist/ui/components/Table/TableFilters.d.ts

@@ -9,4 +9,4 @@ export interface TableFiltersProps extends HTMLAttributes<HTMLDivElement> {
  * Uses filter configuration from Table context.
  * Must be used within a Table component.
  */
-export default function TableFilters({ showClearAll, className, ...props }: TableFiltersProps): import("react/jsx-runtime").JSX.Element | null;
+export default function TableFilters({ showClearAll, className, ...props }: TableFiltersProps): import("react").JSX.Element | null;

package/dist/ui/components/Table/TableHeader.d.ts

@@ -8,4 +8,4 @@ export interface TableHeaderProps extends Omit<HTMLAttributes<HTMLTableSectionEl
  * Renders the table header (thead) with columns.
  * Must be used within a Table component.
  */
-export default function TableHeader({ className, ...props }: TableHeaderProps): import("react/jsx-runtime").JSX.Element;
+export default function TableHeader({ className, ...props }: TableHeaderProps): import("react").JSX.Element;

package/dist/ui/components/Table/TableHeaderCell.d.ts

@@ -15,4 +15,4 @@ export interface TableHeaderCellProps extends HTMLAttributes<HTMLTableCellElemen
  * Supports sorting if column is sortable.
  * Must be used within a Table component.
  */
-export default function TableHeaderCell({ column, resizable, width, onResize, minWidth, maxWidth, className, ...props }: TableHeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export default function TableHeaderCell({ column, resizable, width, onResize, minWidth, maxWidth, className, ...props }: TableHeaderCellProps): import("react").JSX.Element;

package/dist/ui/components/Table/TableHeaderRow.d.ts

@@ -6,4 +6,4 @@ export type TableHeaderRowProps = HTMLAttributes<HTMLTableRowElement>;
  * Renders a header row (tr) with header cells.
  * Must be used within a Table component.
  */
-export default function TableHeaderRow({ className, ...props }: TableHeaderRowProps): import("react/jsx-runtime").JSX.Element;
+export default function TableHeaderRow({ className, ...props }: TableHeaderRowProps): import("react").JSX.Element;

package/dist/ui/components/Table/TablePagination/TablePagination.d.ts

@@ -26,4 +26,4 @@ export interface TablePaginationProps extends HTMLAttributes<HTMLDivElement> {
  * />
  * ```
  */
-export default function TablePagination({ page, pageSize, total, onPageChange, onPageSizeChange, pageSizeOptions, showPageSizeSelector, showPageInfo, className, ...props }: TablePaginationProps): import("react/jsx-runtime").JSX.Element;
+export default function TablePagination({ page, pageSize, total, onPageChange, onPageSizeChange, pageSizeOptions, showPageSizeSelector, showPageInfo, className, ...props }: TablePaginationProps): import("react").JSX.Element;

package/dist/ui/components/Table/TablePagination.d.ts

@@ -11,4 +11,4 @@ export interface TablePaginationProps extends HTMLAttributes<HTMLDivElement> {
  * Uses pagination state from Table context.
  * Must be used within a Table component.
  */
-export default function TablePagination({ showPageSizeSelector, showPageInfo, pageSizeOptions, className, ...props }: TablePaginationProps): import("react/jsx-runtime").JSX.Element | null;
+export default function TablePagination({ showPageSizeSelector, showPageInfo, pageSizeOptions, className, ...props }: TablePaginationProps): import("react").JSX.Element | null;

package/dist/ui/components/Table/TableProvider.d.ts

@@ -52,4 +52,4 @@ export interface TableProviderProps<T extends Record<string, unknown> = Record<s
  * Manages table state (pagination, sorting, filters, selection) and provides it via Context.
  * Supports both client-side and server-side pagination with auto-detection.
  */
-export declare function TableProvider<T extends Record<string, unknown> = Record<string, unknown>>({ columns, data, loading, paginationMode: explicitMode, page: controlledPage, pageSize: controlledPageSize, total: externalTotal, onPageChange, onPageSizeChange, defaultPageSize, pageSizeOptions: _pageSizeOptions, sortColumn: controlledSortColumn, sortDirection: controlledSortDirection, onSort, defaultSortColumn, defaultSortDirection, filters, filterValues: controlledFilterValues, onFilter, initialFilterValues, selectable, selectedRows: controlledSelectedRows, onSelectionChange, rowId, actions, emptyMessage, emptyStateTitle, emptyStateMessage, emptyStateIllustration, emptyStateAction, onRowClick, resizable, columnWidths, onColumnResize, virtualScrolling, virtualScrollingOptions: _virtualScrollingOptions, children, }: TableProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function TableProvider<T extends Record<string, unknown> = Record<string, unknown>>({ columns, data, loading, paginationMode: explicitMode, page: controlledPage, pageSize: controlledPageSize, total: externalTotal, onPageChange, onPageSizeChange, defaultPageSize, pageSizeOptions: _pageSizeOptions, sortColumn: controlledSortColumn, sortDirection: controlledSortDirection, onSort, defaultSortColumn, defaultSortDirection, filters, filterValues: controlledFilterValues, onFilter, initialFilterValues, selectable, selectedRows: controlledSelectedRows, onSelectionChange, rowId, actions, emptyMessage, emptyStateTitle, emptyStateMessage, emptyStateIllustration, emptyStateAction, onRowClick, resizable, columnWidths, onColumnResize, virtualScrolling, virtualScrollingOptions, children, }: TableProviderProps<T>): import("react").JSX.Element;

package/dist/ui/components/Table/TableRow.d.ts

@@ -12,4 +12,4 @@ export interface TableRowProps<T extends Record<string, unknown> = Record<string
  * Supports selection and row click.
  * Must be used within a Table component.
  */
-export default function TableRow<T extends Record<string, unknown> = Record<string, unknown>>({ row, rowIndex, className, onClick, style, ...props }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export default function TableRow<T extends Record<string, unknown> = Record<string, unknown>>({ row, rowIndex, className, onClick, style, ...props }: TableRowProps<T>): import("react").JSX.Element;

package/dist/ui/components/Tabs/TabsContent.d.ts

@@ -11,4 +11,4 @@ export interface TabsContentProps extends HTMLAttributes<HTMLDivElement> {
  * Only renders when the tab is active (unless forceMount is true).
  * Must be used within a Tabs component.
  */
-export declare function TabsContent({ value, children, forceMount, className, ...props }: TabsContentProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function TabsContent({ value, children, forceMount, className, ...props }: TabsContentProps): import("react").JSX.Element | null;

package/dist/ui/components/Tabs/TabsList.d.ts

@@ -1,7 +1,14 @@
-import { type HTMLAttributes, ReactNode } from "react";
-export interface TabsListProps extends HTMLAttributes<HTMLDivElement> {
+import { type HTMLAttributes, type ReactNode } from "react";
+export interface TabsListProps extends Omit<HTMLAttributes<HTMLDivElement>, "orientation"> {
     children: ReactNode;
     variant?: "default" | "compact";
+    /**
+     * Override orientation set on the `Tabs` provider. When omitted,
+     * inherits from context (default "horizontal"). Controls keyboard
+     * navigation axis (ArrowLeft/Right vs ArrowUp/Down), flex direction,
+     * and `aria-orientation`.
+     */
+    orientation?: "horizontal" | "vertical";
 }
 /**
  * TabsList Component
@@ -9,5 +16,7 @@ export interface TabsListProps extends HTMLAttributes<HTMLDivElement> {
  * Container for tab triggers.
  * Manages keyboard navigation between tabs.
  * Must be used within a Tabs component.
+ *
+ * Orientation precedence: local `orientation` prop > Tabs context > "horizontal".
  */
-export declare function TabsList({ children, className, variant, ...props }: TabsListProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabsList({ children, className, variant, orientation: orientationProp, ...props }: TabsListProps): import("react").JSX.Element;

package/dist/ui/components/Tabs/TabsProvider.d.ts

@@ -13,4 +13,4 @@ export interface TabsProviderProps {
  * Provides Tabs context to children.
  * Manages active tab state and handles controlled/uncontrolled modes.
  */
-export declare function TabsProvider({ defaultValue, value: controlledValue, onValueChange, orientation, activationMode, children, }: TabsProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabsProvider({ defaultValue, value: controlledValue, onValueChange, orientation, activationMode, children, }: TabsProviderProps): import("react").JSX.Element;

package/dist/ui/components/Tabs/TabsTrigger.d.ts

@@ -10,4 +10,4 @@ export interface TabsTriggerProps extends HTMLAttributes<HTMLButtonElement> {
  * Individual tab trigger button.
  * Must be used within a TabsList component.
  */
-export declare function TabsTrigger({ value, children, disabled, className, onClick, onKeyDown, ...props }: TabsTriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function TabsTrigger({ value, children, disabled, className, onClick, onKeyDown, ...props }: TabsTriggerProps): import("react").JSX.Element;

package/dist/ui/components/TimePicker/TimePicker.d.ts

@@ -26,4 +26,4 @@ export interface TimePickerProps {
  * />
  * ```
  */
-export default function TimePicker({ value: controlledValue, defaultValue, format, onChange, disabled, label, error, helperText, className, }: TimePickerProps): import("react/jsx-runtime").JSX.Element;
+export default function TimePicker({ value: controlledValue, defaultValue, format, onChange, disabled, label, error, helperText, className, }: TimePickerProps): import("react").JSX.Element;

package/dist/ui/components/Timeline/Timeline.d.ts

@@ -31,4 +31,4 @@ export interface TimelineProps {
  * />
  * ```
  */
-export default function Timeline({ items, orientation, className, }: TimelineProps): import("react/jsx-runtime").JSX.Element;
+export default function Timeline({ items, orientation, className, }: TimelineProps): import("react").JSX.Element;

package/dist/ui/components/Toast/Toast.d.ts

@@ -5,4 +5,4 @@ export interface ToastProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"
     onDismiss: (id: string) => void;
     position?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
 }
-export declare function Toast({ toast, onDismiss, position, className, style, ...props }: ToastProps): import("react/jsx-runtime").JSX.Element;
+export declare function Toast({ toast, onDismiss, position, className, style, ...props }: ToastProps): import("react").JSX.Element;

package/dist/ui/components/Toast/ToastContainer.d.ts

@@ -2,4 +2,4 @@ export interface ToastContainerProps {
     position?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
     maxToasts?: number;
 }
-export declare function ToastContainer({ position, maxToasts, }: ToastContainerProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function ToastContainer({ position, maxToasts, }: ToastContainerProps): import("react").JSX.Element | null;

package/dist/ui/components/index.d.ts

@@ -12,7 +12,7 @@ export * from "./Tabs";
 export { default as SearchInput } from "./SearchInput";
 export type { SearchInputProps } from "./SearchInput";
 export * from "./Autocomplete";
-export type { AutocompleteProps, AutocompleteOption, AutocompleteOptionProps, AutocompleteListProps, } from "./Autocomplete";
+export type { AutocompleteProps, AutocompleteOptionProps, AutocompleteListProps, } from "./Autocomplete";
 export * from "./MultiSelect";
 export type { MultiSelectProps } from "./MultiSelect";
 export { default as Rating } from "./Rating";

package/dist/ui/hooks/createGenericContext.d.ts

@@ -0,0 +1,85 @@
+import { type Context, type JSX, type ReactNode } from "react";
+/**
+ * Options for createGenericContext.
+ */
+export interface CreateGenericContextOptions {
+    /**
+     * displayName surfaced in React DevTools for the underlying Context.
+     */
+    displayName: string;
+    /**
+     * Error thrown by the required hook when called outside the Provider
+     * tree. Keep this verbatim to whatever the legacy hook threw — it is
+     * a behavioural contract consumers rely on.
+     */
+    errorMessage: string;
+}
+/**
+ * Surface returned by createGenericContext.
+ *
+ * @typeParam TBase - The "default" shape stored in the underlying
+ *  React Context. For generic context families this is the type fully
+ *  instantiated at the default generic argument (e.g. for
+ *  `XxxContextValue<TGeneric extends Base = Base>` use
+ *  `XxxContextValue` — no argument — which TS resolves to the default).
+ */
+export interface GenericContext<TBase> {
+    /**
+     * Raw React Context object. Exposed unchanged so existing consumers
+     * (especially `useContextSelector`) keep working. `useContext(Context)`
+     * returns `TBase | undefined`; the typed hooks below carry the
+     * per-call generic.
+     */
+    Context: Context<TBase | undefined>;
+    /**
+     * Generic Provider. Accepts `value` typed at the per-call `TSpecific`,
+     * not at `TBase`, so each call site is cast-free.
+     *
+     * Inside, the single `as TBase` assignment encodes the cost of React's
+     * invariant Context typing — see the implementation comment for the
+     * full reason.
+     */
+    Provider: <TSpecific = TBase>(props: {
+        value: TSpecific;
+        children: ReactNode;
+    }) => JSX.Element;
+    /**
+     * Required hook. Returns the context value typed at the per-call
+     * `TSpecific` (defaults to `TBase`). Throws `options.errorMessage`
+     * when called outside the Provider tree.
+     */
+    useContextRequired: <TSpecific = TBase>() => TSpecific;
+    /**
+     * Optional variant — returns `undefined` outside the Provider tree
+     * instead of throwing.
+     */
+    useContextOptional: <TSpecific = TBase>() => TSpecific | undefined;
+}
+/**
+ * Build a React Context family where the value carries a per-call
+ * generic that is preserved at the Provider and at the consuming hook
+ * site, without spreading `as unknown as` casts through every consumer.
+ *
+ * The motivation: React's `Context<T>` is invariant in `T`. A generic
+ * value type whose generic flows into an invariant inner position
+ * (e.g. `UseFormReturn<T>` inside `FormContextValue<T>`, or
+ * `TableColumn<T>` / `(row: T) => …` inside `TableContextValue<T>`)
+ * cannot be made structurally assignable to its default-generic
+ * counterpart. The cast is irreducible. This factory confines it to
+ * three sites inside the helper — the Provider value and both hook
+ * returns — and consumers stay cast-free.
+ *
+ * @example
+ * ```ts
+ * const formContext = createGenericContext<FormContextValue>({
+ *   displayName: "FormContext",
+ *   errorMessage: "useFormContext must be used within a Form …",
+ * });
+ *
+ * export const FormContext = formContext.Context;
+ * export function useFormContext<T extends FieldValues = FieldValues>() {
+ *   return formContext.useContextRequired<FormContextValue<T>>();
+ * }
+ * ```
+ */
+export declare function createGenericContext<TBase>(options: CreateGenericContextOptions): GenericContext<TBase>;

package/dist/ui/hooks/focusable.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared focusable-element helpers consumed by the focus-management
+ * hooks (`useFocusTrap`, `useAutoFocus`). Centralised so the selector
+ * and visibility filter have one definition — if the rules change
+ * (a new tabbable role lands, jsdom's offsetParent quirk needs a
+ * different handling pivot, etc.), there's exactly one site to edit.
+ *
+ * Originally lived inline in `DialogContent`'s focus trap; the trap
+ * hook took ownership in Phase 3 PR 1, and PR 2 split it out again
+ * once `useAutoFocus` became the second consumer.
+ */
+/**
+ * Selector covering tabbable elements per WAI-ARIA Authoring Practices.
+ * Mirrors the selector DialogContent has shipped with since the dialog
+ * pattern landed.
+ */
+export declare const FOCUSABLE_SELECTOR = "button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])";
+/**
+ * Return the focusable descendants of `container` that are eligible to
+ * receive Tab focus.
+ *
+ * Filters out:
+ *  - `disabled` form controls (button/input/select/textarea expose the
+ *    DOM property; the cast is safe at the call site because every
+ *    selector match either has the property or returns `undefined`,
+ *    which short-circuits to falsy).
+ *  - hidden elements (`offsetParent === null` — covers `display: none`,
+ *    `visibility: hidden`, detached subtrees). In jsdom this filter
+ *    rejects every connected element because jsdom doesn't compute
+ *    layout; tests work around this by stubbing `offsetParent` on the
+ *    nodes they care about. Production stays correct.
+ */
+export declare function getFocusableElements(container: HTMLElement): HTMLElement[];

package/dist/ui/hooks/useAutoFocus.d.ts

@@ -0,0 +1,37 @@
+import { type RefObject } from "react";
+/**
+ * On `isActive` rising edge, move keyboard focus to the first focusable
+ * element inside `containerRef`. Falls back to focusing the container
+ * itself (after temporarily setting `tabindex="-1"` if needed) when the
+ * container has no focusable children — so the modal still owns focus
+ * and Escape/Tab handlers attached to it remain reachable.
+ *
+ * Deferred via `setTimeout(0)`, matching the timing the existing Dialog
+ * implementation proved out. Two reasons that timing matters:
+ *
+ *   1. The overlay's content (button, input, link) is committed to the
+ *      DOM in the same render that flips `isActive` true. Synchronous
+ *      focus from inside the effect can land on the *previous* DOM
+ *      snapshot in React 19's concurrent paths; the timer guarantees
+ *      we run after commit.
+ *   2. Composes with `useFocusRestore`. Restore snapshots
+ *      `document.activeElement` on open *before* this hook moves focus
+ *      inside the overlay — order guaranteed by the snapshot running in
+ *      its own effect at the rising edge while auto-focus is deferred.
+ *
+ * Idempotent on `isActive=false`: the hook does nothing on the falling
+ * edge (focus restoration is `useFocusRestore`'s concern; this hook
+ * only handles the rising-edge auto-focus).
+ *
+ * @example
+ * ```tsx
+ * function MyModal({ isOpen }: { isOpen: boolean }) {
+ *   const contentRef = useRef<HTMLDivElement>(null);
+ *   useFocusRestore(isOpen);
+ *   useFocusTrap(contentRef, isOpen);
+ *   useAutoFocus(contentRef, isOpen);
+ *   // ...
+ * }
+ * ```
+ */
+export declare function useAutoFocus(containerRef: RefObject<HTMLElement | null>, isActive: boolean): void;

package/dist/ui/hooks/useFocusRestore.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Snapshot focus when an overlay opens; restore on close.
+ *
+ * When `isOpen` flips from false to true, snapshots
+ * `document.activeElement` at that moment. When `isOpen` flips back to
+ * false, restores focus to the snapshotted element in a `setTimeout(0)`
+ * — matching the timing the existing DialogProvider proved out
+ * (Dialog.test.tsx:221 depends on this exact shape).
+ *
+ * Trigger-ref-free by design: the snapshot mechanism captures whatever
+ * had focus at open time, so overlays can be opened by any composition
+ * (button click, programmatic call from a notification, etc.) without
+ * carrying a ref to a single triggering element.
+ *
+ * Scope is restore only. Focus trapping (Tab cycling within an open
+ * modal container) is the separate concern of `useFocusTrap`. The two
+ * hooks compose: modal surfaces (Dialog, Drawer) use both; non-modal
+ * surfaces (Popover) use only restore.
+ *
+ * @example
+ * ```tsx
+ * function MyOverlay({ isOpen }: { isOpen: boolean }) {
+ *   useFocusRestore(isOpen);
+ *   // ...
+ * }
+ * ```
+ */
+export declare function useFocusRestore(isOpen: boolean): void;

package/dist/ui/hooks/useFocusTrap.d.ts

@@ -0,0 +1,33 @@
+import { type RefObject } from "react";
+/**
+ * Trap Tab / Shift+Tab cycling within `containerRef` while `isActive`.
+ *
+ * Boundary-only intervention: the handler intercepts Tab on the LAST
+ * focusable element (cycles back to first) and Shift+Tab on the FIRST
+ * focusable element (cycles back to last). Tab/Shift+Tab on any
+ * intermediate element falls through to the browser's default
+ * sequential focus navigation. This is the exact shape the existing
+ * `DialogContent` proved out — extracting it here means there's only
+ * one place to fix when the subtle parts (disabled filtering,
+ * `offsetParent !== null`, zero-focusable edge case) need to evolve.
+ *
+ * Zero-focusable edge case: if the container has no tabbable elements,
+ * Tab and Shift+Tab are both preventDefault'd, so focus can't escape
+ * the trap onto the underlying page. The container can still be closed
+ * via Escape (a concern of the consumer, not this hook).
+ *
+ * Trap is restore-only on the focus side: it does NOT auto-focus the
+ * first element when activated (the consumer typically handles that
+ * separately) and it does NOT snapshot/restore focus on toggle (that's
+ * `useFocusRestore`'s job — the two hooks compose).
+ *
+ * @example
+ * ```tsx
+ * function MyModal({ isOpen, ... }) {
+ *   const contentRef = useRef<HTMLDivElement>(null);
+ *   useFocusTrap(contentRef, isOpen);
+ *   // ...
+ * }
+ * ```
+ */
+export declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, isActive: boolean): void;

package/dist/ui/primitives/Avatar/AvatarGroup.d.ts

@@ -23,4 +23,4 @@ export interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
  * </AvatarGroup>
  * ```
  */
-export declare function AvatarGroup({ children, max, size, variant, spacing, className, ...props }: AvatarGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function AvatarGroup({ children, max, size, variant, spacing, className, ...props }: AvatarGroupProps): import("react").JSX.Element;

package/dist/ui/primitives/Checkbox/Checkbox.d.ts

@@ -2,6 +2,15 @@ import type { InputHTMLAttributes, ReactNode } from "react";
 export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
     label?: ReactNode;
     error?: boolean;
+    /**
+     * Validation success state — paints the border and (when
+     * `helperText` is also set) the helper-text color green. Matches
+     * the Input + Select + Radio + Switch + Textarea convention; the
+     * three feedback flags (`error`, `success`, `helperText`) cover
+     * every form primitive in the DS. Error takes precedence when
+     * both `error` and `success` are set.
+     */
+    success?: boolean;
     helperText?: string;
     indeterminate?: boolean;
 }