altum 0.0.7 → 0.0.9

package/types/index.d.ts

@@ -1,25 +1,35 @@
-import * as react from 'react';
-import react__default, { ComponentPropsWithoutRef, ReactNode, ComponentPropsWithRef, Ref, ReactElement, ButtonHTMLAttributes, ForwardRefExoticComponent, RefAttributes, ElementType, AriaRole, FC, HTMLAttributes } from 'react';
+import * as React from 'react';
+import React__default, { ComponentPropsWithoutRef, Ref, ReactNode, AnchorHTMLAttributes, ButtonHTMLAttributes, MouseEvent, CSSProperties, ReactElement, AriaRole, MutableRefObject, ElementType, FC, HTMLAttributes } from 'react';
 
 type AccordionVariant = 'bordered' | 'flush';
-interface AccordionProps extends ComponentPropsWithoutRef<'div'> {
-    children: react__default.ReactNode;
+interface AccordionItemData {
+    value: string;
+    title: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    disabled?: boolean;
+    headingLevel?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+}
+interface AccordionProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    children?: React__default.ReactNode;
+    items?: AccordionItemData[];
     multiple?: boolean;
     variant?: AccordionVariant;
     defaultOpenIds?: string[];
-    openIds?: string[];
     onOpenChange?: (ids: string[]) => void;
+    rootRef?: Ref<HTMLDivElement>;
 }
-interface AccordionItemProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
+interface AccordionItemProps extends Omit<ComponentPropsWithoutRef<'details'>, 'title' | 'open' | 'name'> {
     value: string;
-    title: react__default.ReactNode;
+    title: React__default.ReactNode;
     disabled?: boolean;
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
     headingLevel?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    rootRef?: Ref<HTMLDetailsElement>;
 }
 
-declare const AccordionItem: react__default.ForwardRefExoticComponent<AccordionItemProps & react__default.RefAttributes<HTMLDivElement>>;
-type AccordionComponent = react__default.ForwardRefExoticComponent<AccordionProps & react__default.RefAttributes<HTMLDivElement>> & {
+declare function AccordionRoot({ children, items, multiple, variant, defaultOpenIds, onOpenChange, className, rootRef, ...rest }: AccordionProps): React.JSX.Element;
+declare function AccordionItem({ value, disabled, className, title, headingLevel: Heading, children, rootRef, ...rest }: AccordionItemProps): React.JSX.Element;
+type AccordionComponent = typeof AccordionRoot & {
     Item: typeof AccordionItem;
 };
 declare const Accordion: AccordionComponent;
@@ -32,27 +42,32 @@ interface AvatarProps extends ComponentPropsWithoutRef<'div'> {
     size?: AvatarSize;
     status?: AvatarStatus;
     icon?: ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
+}
+interface AvatarGroupProps extends ComponentPropsWithoutRef<'div'> {
+    rootRef?: Ref<HTMLDivElement>;
 }
-type AvatarGroupProps = ComponentPropsWithoutRef<'div'>;
 
-declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLDivElement>>;
-declare const AvatarGroup: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare function Avatar({ src, name, size, status, className, icon, style, rootRef, ...rest }: AvatarProps): React.JSX.Element;
+declare function AvatarGroup({ className, rootRef, ...rest }: AvatarGroupProps): React.JSX.Element;
 
 type BadgeVariant = 'error' | 'success' | 'info' | 'warning' | 'primary' | 'secondary';
 type BadgeSize = 'sm' | 'md';
 type BadgePosition = 'overlay' | 'standalone';
 interface BadgeProps extends ComponentPropsWithoutRef<'div'> {
-    label?: react__default.ReactNode;
+    label?: React__default.ReactNode;
     dot?: boolean;
     variant?: BadgeVariant;
     size?: BadgeSize;
     position?: BadgePosition;
     max?: number | false;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLDivElement | HTMLSpanElement>>;
+declare const Badge: ({ label, dot, variant, size, position: positionProp, max, children, className, rootRef, ...rest }: BadgeProps) => React.JSX.Element | null;
 
 type SpacingToken = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type SpacingValue = SpacingToken | number | string;
 type GroupGap = 'sm' | 'md' | 'lg';
 
 type ControlSize = 'sm' | 'md' | 'lg';
@@ -68,75 +83,51 @@ type SurfaceVariant = 'primary' | 'tinted' | 'secondary' | 'ghost' | 'plain';
 
 type ButtonVariant = 'primary' | 'tinted' | 'secondary' | 'danger' | 'danger_tinted' | 'ghost' | 'link';
 type ButtonAs = 'button' | 'a';
-type ButtonRef<T extends ButtonAs> = T extends 'a' ? HTMLAnchorElement : HTMLButtonElement;
-type ButtonOwnProps = {
+type ButtonChrome = {
     variant?: ButtonVariant;
     size?: ControlSize;
     active?: boolean;
     disabled?: boolean;
-    type?: 'button' | 'submit' | 'reset';
-    children?: react__default.ReactNode;
+    children?: ReactNode;
     prefix?: ReactNode;
     postfix?: ReactNode;
     loading?: boolean;
     fullWidth?: boolean;
+    className?: string;
+    as?: ButtonAs;
+    type?: 'button' | 'submit' | 'reset';
+    rootRef?: Ref<HTMLButtonElement | HTMLAnchorElement>;
+    href?: string;
+    target?: AnchorHTMLAttributes<HTMLAnchorElement>['target'];
+    rel?: string;
+    download?: AnchorHTMLAttributes<HTMLAnchorElement>['download'];
 };
-type ButtonProps<T extends ButtonAs = 'button'> = ButtonOwnProps & Omit<ComponentPropsWithRef<T>, keyof ButtonOwnProps | 'as'> & {
-    as?: T;
-};
-
-type ButtonComponent = (<T extends ButtonAs = 'button'>(props: ButtonProps<T> & {
-    ref?: Ref<ButtonRef<T>>;
-}) => ReactElement | null) & {
-    displayName?: string;
-};
-declare const Button: ButtonComponent;
+type ButtonProps = ButtonChrome & Omit<ButtonHTMLAttributes<HTMLButtonElement>, keyof ButtonChrome>;
 
-interface ButtonIconProps extends Omit<ButtonProps, 'children' | 'prefix' | 'postfix' | 'loading' | 'fullWidth'> {
-    shape?: 'circle' | 'square';
-    appearance?: 'default' | 'diskClose';
-    icon?: react__default.ReactNode;
-    children?: react__default.ReactNode;
-}
+declare const Button: (props: ButtonProps) => React.JSX.Element;
 
-declare const ButtonIcon: react.ForwardRefExoticComponent<Omit<ButtonIconProps, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+type ButtonIconProps = ButtonProps & {
+    icon?: ReactNode;
+};
+declare const ButtonIcon: ({ icon, children, ...props }: ButtonIconProps) => React.JSX.Element;
 
-type ButtonGroupMode = 'button' | 'toggle' | 'multi_toggle';
+type ButtonGroupOrientation = 'horizontal' | 'vertical';
 type ButtonGroupItemFit = 'equal' | 'content';
-type ButtonGroupVariant = Exclude<ButtonVariant, 'danger' | 'danger_tinted'> | 'plain';
-interface ButtonGroupRootProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange' | 'defaultValue'> {
-    children: react__default.ReactNode;
-    mode?: ButtonGroupMode;
+type ButtonGroupVariant = Exclude<ButtonVariant, 'link'> | 'pill';
+interface ButtonGroupRootProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    children: ReactNode;
     variant?: ButtonGroupVariant;
-    status?: 'default' | 'danger';
     size?: ControlSize;
     disabled?: boolean;
-    readOnly?: boolean;
-    borderless?: boolean;
     focusable?: boolean;
     width?: 'auto' | 'full';
     itemFit?: ButtonGroupItemFit;
-    value?: string | readonly string[];
-    defaultValue?: string | readonly string[];
-    onChange?: (value: string | string[]) => void;
-    activateOnFocus?: boolean;
+    orientation?: ButtonGroupOrientation;
     'aria-label'?: string;
-}
-interface ButtonGroupItemProps extends Omit<react__default.ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'value'> {
-    value?: string;
-    active?: boolean;
-    icon?: react__default.ReactNode;
-    children?: react__default.ReactNode;
-    className?: string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const ButtonGroupRoot: react__default.ForwardRefExoticComponent<ButtonGroupRootProps & react__default.RefAttributes<HTMLDivElement>>;
-declare const ButtonGroupItem: react__default.ForwardRefExoticComponent<ButtonGroupItemProps & react__default.RefAttributes<HTMLButtonElement>>;
-type ButtonGroupComponent = react__default.ForwardRefExoticComponent<ButtonGroupRootProps & react__default.RefAttributes<HTMLDivElement>> & {
-    Root: typeof ButtonGroupRoot;
-    Item: typeof ButtonGroupItem;
-};
-declare const ButtonGroup: ButtonGroupComponent;
+declare const ButtonGroup: ({ children, variant, size, disabled, focusable, width, itemFit, orientation, role, "aria-label": ariaLabel, className, onKeyDown, rootRef, ...rest }: ButtonGroupRootProps) => React.JSX.Element;
 
 type ChipVariant = 'primary' | 'tinted' | 'secondary' | 'success' | 'info' | 'warning' | 'error';
 type ChipMode = 'chip' | 'tag' | 'toggle';
@@ -144,25 +135,29 @@ interface ChipProps extends Omit<ComponentPropsWithoutRef<'span'>, 'onClick'> {
     variant?: ChipVariant;
     size?: ControlSize;
     mode?: ChipMode;
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     onRemove?: () => void;
-    onClick?: react__default.MouseEventHandler<HTMLButtonElement | HTMLSpanElement>;
+    onClick?: React__default.MouseEventHandler<HTMLButtonElement | HTMLSpanElement>;
     disabled?: boolean;
-    icon?: react__default.ReactNode;
+    icon?: React__default.ReactNode;
     className?: string;
     removeLabel?: string;
+    rootRef?: Ref<HTMLButtonElement | HTMLSpanElement>;
+    value?: string;
 }
 type ChipGroupGap = GroupGap;
-interface ChipGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    children: react__default.ReactNode;
+interface ChipGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onSelect'> {
+    children: React__default.ReactNode;
     'aria-label'?: string;
     gap?: ChipGroupGap;
     mode?: Exclude<ChipMode, 'toggle'>;
+    onSelect?: (value: string) => void;
     className?: string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Chip: react.ForwardRefExoticComponent<ChipProps & react.RefAttributes<HTMLButtonElement | HTMLSpanElement>>;
-declare const ChipGroup: react.ForwardRefExoticComponent<ChipGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const Chip: ({ variant, size, mode, children, onRemove, onClick, disabled, icon, className, removeLabel, rootRef, value, ...rest }: ChipProps) => React.JSX.Element;
+declare const ChipGroup: ({ children, "aria-label": ariaLabel, gap, mode, onSelect, onClick, className, style, rootRef, ...rest }: ChipGroupProps) => React.JSX.Element;
 
 interface ColorSwatchGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange' | 'defaultValue'> {
     colors: string[];
@@ -172,48 +167,52 @@ interface ColorSwatchGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'c
     label?: string;
     readOnly?: boolean;
     disabled?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const ColorSwatchGroup: react.ForwardRefExoticComponent<ColorSwatchGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare function ColorSwatchGroup({ colors, value, onChange, size, label, className, readOnly, disabled, rootRef, ...rest }: ColorSwatchGroupProps): React.JSX.Element;
 
 type EmptyStateSize = 'sm' | 'md' | 'lg';
 interface EmptyStateProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'title'> {
-    icon?: react__default.ReactNode;
+    icon?: React__default.ReactNode;
     title: string;
     description?: string;
-    action?: react__default.ReactNode;
+    action?: React__default.ReactNode;
     size?: EmptyStateSize;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const EmptyState: react.ForwardRefExoticComponent<EmptyStateProps & react.RefAttributes<HTMLDivElement>>;
+declare function EmptyState({ icon, title, description, action, size, className, rootRef, ...rest }: EmptyStateProps): React.JSX.Element;
 
 type FieldGroupWidth = 'auto' | 'full';
 interface FieldGroupProps extends ComponentPropsWithoutRef<'div'> {
     width?: FieldGroupWidth;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const FieldGroup: react.ForwardRefExoticComponent<FieldGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare function FieldGroup({ width, className, children, style, rootRef, ...rest }: FieldGroupProps): React.JSX.Element;
 
 type FieldsetVariant = 'default' | 'card' | 'plain';
 interface FieldsetProps extends ComponentPropsWithoutRef<'div'> {
     variant?: FieldsetVariant;
     disabled?: boolean;
-    children?: react__default.ReactNode;
-    legend?: react__default.ReactNode;
-    description?: react__default.ReactNode;
-    hint?: react__default.ReactNode;
-    footer?: react__default.ReactNode;
+    children?: React__default.ReactNode;
+    legend?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    hint?: React__default.ReactNode;
+    footer?: React__default.ReactNode;
     gap?: number | string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Fieldset: react.ForwardRefExoticComponent<FieldsetProps & react.RefAttributes<HTMLDivElement>>;
+declare function Fieldset({ variant, disabled, className, style, id: providedId, children, legend, description, hint, footer, gap, rootRef, ...rest }: FieldsetProps): React.JSX.Element;
 
 type FieldLabelLayout = 'vertical' | 'horizontal';
 type FieldLabelAlign = 'start' | 'center' | 'baseline';
 type FieldLabelJustify = 'start' | 'between';
 interface FieldLabelProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    label: react__default.ReactNode;
-    children: react__default.ReactNode;
+    label: React__default.ReactNode;
+    children: React__default.ReactNode;
     layout?: FieldLabelLayout;
     size?: ControlSize;
     htmlFor?: string;
@@ -223,9 +222,10 @@ interface FieldLabelProps extends Omit<ComponentPropsWithoutRef<'div'>, 'childre
     labelClassName?: string;
     contentClassName?: string;
     id?: string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const FieldLabel: react.ForwardRefExoticComponent<FieldLabelProps & react.RefAttributes<HTMLDivElement>>;
+declare function FieldLabel({ label, children, layout, size, htmlFor, labelWidth, align, justify, className, style, labelClassName, contentClassName, id: providedId, rootRef, ...rest }: FieldLabelProps): React.JSX.Element;
 
 interface FieldBaseProps {
     label?: string;
@@ -242,40 +242,41 @@ interface FieldBaseProps {
 }
 interface FieldBaseButtonProps extends ComponentPropsWithoutRef<'button'> {
     icon?: ReactNode;
+    rootRef?: Ref<HTMLButtonElement>;
 }
 interface FieldBaseIconProps extends ComponentPropsWithoutRef<'span'> {
     children: ReactNode;
+    rootRef?: Ref<HTMLSpanElement>;
 }
 type TextFieldAs = 'input' | 'textarea' | 'button' | 'div';
 type TextFieldRef<T extends TextFieldAs> = T extends 'textarea' ? HTMLTextAreaElement : T extends 'button' ? HTMLButtonElement : T extends 'div' ? HTMLDivElement : HTMLInputElement;
 type TextFieldOwnProps = FieldBaseProps & {
     wrapperClassName?: string;
-    wrapperRef?: Ref<HTMLDivElement>;
+    rootRef?: Ref<HTMLElement>;
     wrapperProps?: Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'prefix'>;
     active?: boolean;
     keepPlaceholder?: boolean;
     controlOverlay?: ReactNode;
     hasValue?: boolean;
 };
-type TextFieldProps<T extends TextFieldAs = 'input'> = TextFieldOwnProps & Omit<ComponentPropsWithRef<T>, keyof TextFieldOwnProps | 'as' | 'prefix' | 'size' | 'width'> & {
+type TextFieldProps<T extends TextFieldAs = 'input'> = TextFieldOwnProps & Omit<ComponentPropsWithoutRef<T>, keyof TextFieldOwnProps | 'as' | 'prefix' | 'size' | 'width'> & {
     as?: T;
+    inputRef?: Ref<TextFieldRef<T>>;
 };
 
-declare const FieldBaseButton: react__default.ForwardRefExoticComponent<FieldBaseButtonProps & react__default.RefAttributes<HTMLButtonElement>>;
-declare const FieldBaseIcon: react__default.ForwardRefExoticComponent<FieldBaseIconProps & react__default.RefAttributes<HTMLSpanElement>>;
-type TextFieldComponent = (<T extends TextFieldAs = 'input'>(props: TextFieldProps<T> & {
-    ref?: Ref<TextFieldRef<T>>;
-}) => ReactElement | null) & {
-    displayName?: string;
-};
-declare const TextField: TextFieldComponent;
+declare function FieldBaseButton({ className, icon, children, type, rootRef, ...props }: FieldBaseButtonProps): React.JSX.Element;
+declare function FieldBaseIcon({ className, children, rootRef, ...props }: FieldBaseIconProps): React.JSX.Element;
+declare function TextField<T extends TextFieldAs = 'input'>(props: TextFieldProps<T>): React.JSX.Element;
 
-type SearchFieldProps = Omit<TextFieldProps, 'prefix' | 'type'>;
+type SearchFieldProps = Omit<TextFieldProps, 'prefix' | 'type' | 'ref'> & {
+    inputRef?: Ref<HTMLInputElement>;
+};
 
-declare const SearchField: react.ForwardRefExoticComponent<Omit<SearchFieldProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare const SearchField: ({ label, "aria-label": ariaLabel, inputRef, ...props }: SearchFieldProps) => React.JSX.Element;
 
 type SkeletonVariant = 'block' | 'text' | 'avatar' | 'card' | 'table';
 interface SkeletonProps extends ComponentPropsWithoutRef<'div'> {
+    rootRef?: Ref<HTMLDivElement>;
     variant?: SkeletonVariant;
     width?: string | number;
     height?: string | number;
@@ -288,49 +289,50 @@ interface SkeletonProps extends ComponentPropsWithoutRef<'div'> {
     columns?: number;
 }
 
-declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLDivElement>>;
+declare const Skeleton: ({ variant, width, height, circle, lines, lastWidth, size, avatar, rows, columns, className, style, rootRef, ...rest }: SkeletonProps) => React.JSX.Element;
 
 interface StatBadgeProps extends ComponentPropsWithoutRef<'div'> {
     label: string;
     value: number | string;
     variant?: 'default' | 'success' | 'warning' | 'error';
     size?: 'sm' | 'md';
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const StatBadge: react.ForwardRefExoticComponent<StatBadgeProps & react.RefAttributes<HTMLDivElement>>;
+declare const StatBadge: ({ label, value, variant, size, className, rootRef, style, ...rest }: StatBadgeProps) => React.JSX.Element;
 
 type BoxVariant = 'outlined' | 'elevated' | 'floating' | 'tinted' | 'secondary' | 'muted' | 'glass' | 'overlay' | 'ghost' | 'plain';
 type BoxShadow = 'none' | 'sm' | 'md' | 'lg';
 type BoxBorderStyle = 'solid' | 'dashed';
-type BoxPadding = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type BoxRadius = 'none' | 'sm' | 'md' | 'lg';
-type BoxAs = 'div' | 'section' | 'article' | 'aside' | 'button' | 'a' | 'li';
+type BoxAs = 'div' | 'section' | 'article' | 'aside' | 'main' | 'nav' | 'button' | 'a' | 'li' | 'ul' | 'ol' | 'dl' | 'span';
 interface BoxProps extends ComponentPropsWithoutRef<'div'> {
     variant?: BoxVariant;
     border?: boolean;
     borderStyle?: BoxBorderStyle;
     shadow?: BoxShadow;
     as?: BoxAs;
-    padding?: BoxPadding;
     radius?: BoxRadius;
+    rootRef?: Ref<HTMLElement> | Ref<HTMLDivElement> | Ref<HTMLSpanElement> | Ref<HTMLButtonElement> | Ref<HTMLAnchorElement> | Ref<HTMLUListElement> | Ref<HTMLOListElement> | Ref<HTMLLIElement> | Ref<HTMLDListElement>;
 }
 
-declare const Box: react.ForwardRefExoticComponent<BoxProps & react.RefAttributes<HTMLElement>>;
+declare const Box: ({ variant, border, borderStyle, shadow, as: Component, radius, className, rootRef, ...rest }: BoxProps) => React.JSX.Element;
 
 type CardVariant = Extract<BoxVariant, 'outlined' | 'elevated' | 'ghost'>;
 interface CardProps extends ComponentPropsWithoutRef<'div'> {
-    children?: react__default.ReactNode;
-    header?: react__default.ReactNode;
-    media?: react__default.ReactNode;
-    actions?: react__default.ReactNode;
+    children?: React__default.ReactNode;
+    header?: React__default.ReactNode;
+    media?: React__default.ReactNode;
+    actions?: React__default.ReactNode;
     hoverable?: boolean;
     variant?: CardVariant;
     radius?: BoxRadius;
     loading?: boolean;
     as?: BoxAs;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
+declare const Card: ({ children, header, media, actions, hoverable, variant, loading, className, as, onClick, role, radius, rootRef, ...rest }: CardProps) => React.JSX.Element;
 
 type ItemSize = 'sm' | 'md' | 'lg';
 type ItemMediaVariant = 'icon' | 'image' | 'avatar';
@@ -339,6 +341,7 @@ interface ItemProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
     size?: ItemSize;
     variant?: ItemVariant;
     interactive?: boolean;
+    wrap?: boolean;
     as?: BoxAs;
     media?: ReactNode;
     mediaVariant?: ItemMediaVariant;
@@ -349,6 +352,7 @@ interface ItemProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
     descriptionClassName?: string;
     actions?: ReactNode;
     actionsClassName?: string;
+    rootRef?: Ref<HTMLElement>;
 }
 
 type AttachmentSize = 'md' | 'sm' | 'xs';
@@ -356,34 +360,62 @@ type AttachmentStatus = 'idle' | 'uploading' | 'error' | 'done';
 interface AttachmentProps extends Omit<ItemProps, 'size' | 'variant'> {
     size?: AttachmentSize;
     status?: AttachmentStatus;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Attachment: react.ForwardRefExoticComponent<AttachmentProps & react.RefAttributes<HTMLDivElement>>;
+declare function Attachment({ size, status, media, className, rootRef, ...rest }: AttachmentProps): React.JSX.Element;
 
 type FileListItemStatus = 'idle' | 'uploading' | 'done' | 'error';
-interface FileListItemProps extends Omit<ComponentPropsWithoutRef<'li'>, 'id'> {
+interface FileListItemProps extends Omit<ComponentPropsWithoutRef<'li'>, 'id' | 'itemRef'> {
     id: string;
     name: string;
     size?: number | string;
     progress?: number;
     status?: FileListItemStatus;
-    error?: react__default.ReactNode;
+    error?: React__default.ReactNode;
     previewUrl?: string;
     onRemove?: (id: string) => void;
     onRetry?: (id: string) => void;
     removeLabel?: string;
     retryLabel?: string;
     attachmentSize?: AttachmentSize;
+    itemRef?: Ref<HTMLLIElement>;
 }
 interface FileListRootProps extends Omit<ComponentPropsWithoutRef<'ul'>, 'children'> {
-    children: react__default.ReactNode;
+    children?: React__default.ReactNode;
+    items?: FileListItemProps[];
+    onRemove?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    rootRef?: Ref<HTMLUListElement>;
 }
 
-declare const FileList$1: react.ForwardRefExoticComponent<FileListRootProps & react.RefAttributes<HTMLUListElement>> & {
-    Root: react.ForwardRefExoticComponent<FileListRootProps & react.RefAttributes<HTMLUListElement>>;
-    Item: react.ForwardRefExoticComponent<FileListItemProps & react.RefAttributes<HTMLLIElement>>;
+declare function FileListItem({ id, name, size, progress, status: providedStatus, error, previewUrl, onRemove, onRetry, removeLabel, retryLabel, attachmentSize, className, itemRef, ...rest }: FileListItemProps): React.JSX.Element;
+declare function FileListRoot({ children, items, onRemove, onRetry, className, style, rootRef, ...rest }: FileListRootProps): React.JSX.Element;
+declare const FileList$1: typeof FileListRoot & {
+    Root: typeof FileListRoot;
+    Item: typeof FileListItem;
 };
 
+interface FileUploaderFile {
+    id: string;
+    name: string;
+    progress?: number;
+    status?: FileListItemStatus;
+}
+interface FileUploaderProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange'> {
+    files?: FileUploaderFile[];
+    onFiles?: (files: FileList) => void;
+    children?: React__default.ReactNode | ((openFileDialog: () => void) => React__default.ReactNode);
+    multiple?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    onRemove?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    rootRef?: Ref<HTMLDivElement>;
+}
+
+declare function FileUploader({ files, onFiles, children, multiple, disabled, readOnly, onRemove, onRetry, className, rootRef, ...rest }: FileUploaderProps): React.JSX.Element;
+
 interface PinInputProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange' | 'defaultValue'> {
     length?: number;
     size?: ControlSize;
@@ -400,9 +432,10 @@ interface PinInputProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'
     description?: ReactNode;
     name?: string;
     width?: FieldWidth;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const PinInput: react.ForwardRefExoticComponent<PinInputProps & react.RefAttributes<HTMLDivElement>>;
+declare function PinInput({ length, size, value: controlled, defaultValue, onChange, onComplete, numeric, disabled, masked, autoFocus, 'aria-label': ariaLabel, className, style, error, label, description, name, width, rootRef, ...rest }: PinInputProps): React.JSX.Element;
 
 interface RatingProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange' | 'defaultValue'> {
     value?: number;
@@ -413,11 +446,13 @@ interface RatingProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' |
     disabled?: boolean;
     size?: 'sm' | 'md' | 'lg';
     allowClear?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Rating: react.ForwardRefExoticComponent<RatingProps & react.RefAttributes<HTMLDivElement>>;
+declare const Rating: ({ value: controlledValue, defaultValue, onChange, max, readOnly, disabled, size, allowClear, "aria-label": ariaLabel, className, rootRef, onClick, ...rest }: RatingProps) => React.JSX.Element;
 
 interface RelativeTimeProps extends Omit<ComponentPropsWithoutRef<'time'>, 'dateTime'> {
+    rootRef?: Ref<HTMLTimeElement>;
     date: Date | string | number;
     locale?: string;
     updateInterval?: number;
@@ -425,26 +460,28 @@ interface RelativeTimeProps extends Omit<ComponentPropsWithoutRef<'time'>, 'date
 }
 
 declare function formatRelativeTime(date: Date, locale?: string, now?: Date): string;
-declare const RelativeTime: react.ForwardRefExoticComponent<RelativeTimeProps & react.RefAttributes<HTMLTimeElement>>;
+declare const RelativeTime: ({ date, locale, updateInterval, showAbsoluteTitle, className, title, rootRef, ...rest }: RelativeTimeProps) => React.JSX.Element;
 
 interface DescriptionListItem {
     id?: string;
-    label: react__default.ReactNode;
-    value: react__default.ReactNode;
+    label: React__default.ReactNode;
+    value: React__default.ReactNode;
 }
 interface DescriptionListProps extends Omit<ComponentPropsWithoutRef<'dl'>, 'children'> {
     items: DescriptionListItem[];
     layout?: 'stacked' | 'inline';
     columns?: 1 | 2 | 3;
+    rootRef?: Ref<HTMLDListElement>;
 }
 
-declare const DescriptionList: react.ForwardRefExoticComponent<DescriptionListProps & react.RefAttributes<HTMLDListElement>>;
+declare function DescriptionList({ items, layout, columns, className, style, rootRef, ...rest }: DescriptionListProps): React.JSX.Element;
 
 interface AspectRatioProps extends ComponentPropsWithoutRef<'div'> {
     ratio?: number | string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const AspectRatio: react.ForwardRefExoticComponent<AspectRatioProps & react.RefAttributes<HTMLDivElement>>;
+declare function AspectRatio({ ratio, children, className, style, rootRef, ...rest }: AspectRatioProps): React.JSX.Element;
 
 interface MediaProps extends Omit<AspectRatioProps, 'children'> {
     src: string;
@@ -455,41 +492,45 @@ interface MediaProps extends Omit<AspectRatioProps, 'children'> {
     rounded?: boolean;
 }
 
-declare const Media: react.ForwardRefExoticComponent<MediaProps & react.RefAttributes<HTMLDivElement>>;
+declare const Media: ({ src, alt, as, poster, fit, rounded, ratio, className, style, rootRef, onError, ...rest }: MediaProps) => React__default.JSX.Element;
 
 interface ScrollAreaProps extends ComponentPropsWithoutRef<'div'> {
+    rootRef?: Ref<HTMLDivElement>;
     maxHeight?: string | number;
     maxWidth?: string | number;
     orientation?: 'y' | 'x' | 'both';
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
 }
 
-declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
+declare const ScrollArea: ({ maxHeight, maxWidth, orientation, className, style, rootRef, ...rest }: ScrollAreaProps) => React.JSX.Element;
 
 interface VisuallyHiddenProps extends ComponentPropsWithoutRef<'span'> {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     as?: 'span' | 'div' | 'label';
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const VisuallyHidden: react.ForwardRefExoticComponent<VisuallyHiddenProps & react.RefAttributes<HTMLElement>>;
+declare const VisuallyHidden: ({ children, as: Component, className, rootRef, ...rest }: VisuallyHiddenProps) => React.JSX.Element;
 
 interface LiveRegionProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'role'> {
     message?: ReactNode;
     politeness?: 'polite' | 'assertive';
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const LiveRegion: react.ForwardRefExoticComponent<LiveRegionProps & react.RefAttributes<HTMLElement>>;
+declare const LiveRegion: ({ message, politeness, rootRef, ...rest }: LiveRegionProps) => React.JSX.Element | null;
 
 interface SkipLinkProps extends ComponentPropsWithoutRef<'a'> {
     href?: string;
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
+    rootRef?: Ref<HTMLAnchorElement>;
 }
 
-declare const SkipLink: react.ForwardRefExoticComponent<SkipLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const SkipLink: ({ href, children, className, rootRef, ...rest }: SkipLinkProps) => React.JSX.Element;
 
 type CheckboxMode = 'default' | 'task';
 interface CheckboxProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size'> {
-    label?: react__default.ReactNode;
+    label?: React__default.ReactNode;
     labelVisibility?: 'visible' | 'hidden';
     readOnly?: boolean;
     size?: ControlSize;
@@ -498,6 +539,7 @@ interface CheckboxProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size'>
     mode?: CheckboxMode;
     align?: 'start' | 'center';
     onCheckedChange?: (checked: boolean) => void;
+    inputRef?: Ref<HTMLInputElement>;
 }
 interface CheckboxGroupProps extends Omit<ComponentPropsWithoutRef<'fieldset'>, 'children' | 'onChange'> {
     label?: string;
@@ -513,56 +555,91 @@ interface CheckboxGroupProps extends Omit<ComponentPropsWithoutRef<'fieldset'>,
     disabled?: boolean;
     size?: ControlSize;
     labelSide?: LabelSide;
+    rootRef?: Ref<HTMLFieldSetElement>;
 }
 
-declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
-declare const CheckboxGroup: react.ForwardRefExoticComponent<CheckboxGroupProps & react.RefAttributes<HTMLFieldSetElement>>;
+declare const Checkbox: ({ label, labelVisibility, className, disabled, readOnly, size, labelSide, indeterminate, mode, align: alignProp, checked, onChange, onCheckedChange, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, inputRef, ...props }: CheckboxProps) => React.JSX.Element;
+declare const CheckboxGroup: ({ label, options, value, onChange, orientation, readOnly, disabled, size, labelSide, rootRef, ...rest }: CheckboxGroupProps) => React.JSX.Element;
 
 interface CollapseProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     open: boolean;
-    children: react__default.ReactNode;
-    reducedMotion?: boolean;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Collapse: react.ForwardRefExoticComponent<CollapseProps & react.RefAttributes<HTMLDivElement>>;
+declare function Collapse({ open, children, className, rootRef, ...rest }: CollapseProps): React.JSX.Element;
 
-type RenderChildrenFn<P> = (props: P, contentRef: react__default.RefCallback<HTMLElement>) => react__default.ReactNode;
+type RenderChildrenFn<P> = (props: P, contentRef: React__default.RefCallback<HTMLElement>) => React__default.ReactNode;
 type WithEnrichedChildren<T, P> = T & {
-    children: RenderChildrenFn<P> | react__default.ReactElement;
+    children: RenderChildrenFn<P> | React__default.ReactElement;
 };
 
+type PopoverContentVariant = 'panel' | 'plain';
+type PopoverTargetAction = 'toggle' | 'show' | 'hide';
+type PopoverTriggerSlotProps = {
+    popoverTarget?: string;
+    popoverTargetAction?: PopoverTargetAction;
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+    style?: CSSProperties;
+};
+interface PopoverProps {
+    children?: ReactNode;
+    trigger: ReactElement | RenderChildrenFn<PopoverTriggerSlotProps>;
+    id?: string;
+    disabled?: boolean;
+    variant?: PopoverContentVariant;
+    className?: string;
+    role?: AriaRole;
+    side?: AnchorSide;
+    align?: AnchorAlign;
+    widthMode?: 'trigger' | 'content' | 'trigger-fit';
+    popoverTargetAction?: PopoverTargetAction;
+    defaultOpen?: boolean;
+    onToggle?: (open: boolean) => void;
+    panelRef?: Ref<HTMLElement | null>;
+}
+
+type DropdownPopup = {
+    show: () => void;
+    hide: () => void;
+};
 type DropdownPopupRole = 'menu' | 'listbox' | 'none' | 'dialog';
 type DropdownTriggerMode = 'toggle' | 'combobox';
 type DropdownAlign = AnchorAlign | 'auto' | 'left' | 'right';
 type DropdownWidthMode = 'trigger' | 'content' | 'trigger-fit';
 type DropdownPanelScroll = 'overlay' | 'content';
-type DropdownTriggerAttrs = Pick<react__default.HTMLAttributes<HTMLElement>, 'onKeyDown' | 'onClick'> & {
+type DropdownTriggerAttrs = Pick<React__default.HTMLAttributes<HTMLElement>, 'onKeyDown' | 'onClick'> & {
     'aria-haspopup'?: 'true' | 'listbox' | 'menu' | 'dialog';
-    'aria-expanded': boolean;
+    'aria-expanded'?: boolean;
     'aria-controls'?: string;
     tabIndex?: number;
     className?: string;
     type?: 'button';
 };
-type DropdownTriggerSlotProps = DropdownTriggerAttrs;
+type DropdownTriggerSlotProps = DropdownTriggerAttrs & PopoverTriggerSlotProps;
+type DropdownPanelState = {
+    open: boolean;
+};
 interface DropdownProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    children?: react__default.ReactNode;
-    renderTrigger: RenderChildrenFn<DropdownTriggerSlotProps>;
-    open?: boolean;
+    children?: React__default.ReactNode | ((state: DropdownPanelState) => React__default.ReactNode);
+    trigger: React__default.ReactElement | RenderChildrenFn<DropdownTriggerSlotProps>;
+    defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
+    popupRef?: Ref<DropdownPopup | null>;
+    rootRef?: Ref<HTMLDivElement>;
     popupRole?: DropdownPopupRole;
     triggerMode?: DropdownTriggerMode;
     boxProps?: BoxProps;
     align?: DropdownAlign;
     widthMode?: DropdownWidthMode;
-    mobileTitle?: react__default.ReactNode;
-    mobileLeftControls?: react__default.ReactNode;
-    mobileRightControls?: react__default.ReactNode;
+    mobileTitle?: React__default.ReactNode;
+    mobileLeftControls?: React__default.ReactNode;
+    mobileRightControls?: React__default.ReactNode;
     panelScroll?: DropdownPanelScroll;
     panelClassName?: string;
 }
 
-declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.RefAttributes<HTMLDivElement>>;
+declare function Dropdown({ children, trigger, defaultOpen, onOpenChange, popupRef, popupRole, triggerMode, className, boxProps, align, widthMode, panelScroll, mobileTitle, mobileLeftControls, mobileRightControls, panelClassName, rootRef, ...rest }: DropdownProps): React.JSX.Element;
 
 interface ListboxOption {
     value: string;
@@ -584,37 +661,38 @@ interface ResolvedListboxGroup {
 }
 type ListboxFilterFn<T extends ListboxOption = ListboxOption> = (option: T, query: string) => boolean;
 
+interface ListboxSeparator {
+    type: 'separator';
+    id?: string;
+    groupId?: string;
+}
+type ListboxEntry<T extends ListboxOption = ListboxOption> = T | ListboxSeparator;
 type ListboxNavigation = 'roving' | 'highlight';
-interface ListboxProps extends Omit<ComponentPropsWithoutRef<'div'>, 'onSelect' | 'onChange' | 'value' | 'defaultValue' | 'children'> {
-    options: ListboxOption[];
+interface ListboxProps<T extends ListboxOption = ListboxOption> extends Omit<ComponentPropsWithoutRef<'div'>, 'onSelect' | 'onChange' | 'value' | 'defaultValue' | 'children'> {
+    options: readonly ListboxEntry<T>[];
+    customRenderOption?: (option: T) => ReactNode;
     groups?: ListboxGroup[];
     value?: string[];
     multiple?: boolean;
-    onSelect?: (optionValue: string) => void;
+    onSelect?: (optionValue: string, option: T) => void;
     noOptionsText?: string;
     loading?: boolean;
     showCheck?: boolean;
     navigation?: ListboxNavigation;
-    highlightedIndex?: number;
-    defaultHighlightedIndex?: number;
-    onHighlightChange?: (index: number) => void;
-    preventOptionMouseDown?: boolean;
+    activeDescendantId?: string;
+    rootRef?: Ref<HTMLDivElement>;
+    controlRef?: MutableRefObject<ListboxHandle | null>;
     disabled?: boolean;
     multiline?: boolean;
     virtualized?: boolean;
 }
 interface ListboxHandle {
-    highlightNext: () => void;
-    highlightPrev: () => void;
-    highlightFirst: () => void;
-    highlightLast: () => void;
-    selectHighlighted: () => string | undefined;
-    getHighlightedIndex: () => number;
-    getActiveDescendantId: () => string | undefined;
-    focusOption: (index: number) => void;
+    focusFirst: () => void;
+    selectHighlighted: () => void;
+    scrollToId: (id: string) => void;
 }
 
-declare const Listbox: react.ForwardRefExoticComponent<ListboxProps & react.RefAttributes<ListboxHandle>>;
+declare function Listbox<T extends ListboxOption = ListboxOption>({ options, groups, value, multiple, onSelect, customRenderOption, id: providedId, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, noOptionsText: noOptionsTextProp, loading, className, showCheck, navigation, activeDescendantId, disabled, multiline, virtualized, onKeyDown, onClick, rootRef, controlRef, ...rest }: ListboxProps<T>): React.JSX.Element;
 
 interface ActionListItem {
     id: string;
@@ -633,17 +711,8 @@ interface ActionListGroup {
     id: string;
     label: ReactNode;
 }
-interface ActionListHandle {
-    highlightNext: () => void;
-    highlightPrev: () => void;
-    highlightFirst: () => void;
-    highlightLast: () => void;
-    selectHighlighted: () => ActionListItem | undefined;
-    getHighlightedIndex: () => number;
-    getActiveDescendantId: () => string | undefined;
-    getListId: () => string;
-}
 interface ActionListProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onSelect'> {
+    rootRef?: Ref<HTMLDivElement>;
     items: ActionListItem[];
     groups?: ActionListGroup[];
     onAction?: (item: ActionListItem) => void;
@@ -661,18 +730,17 @@ interface MenuProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     children?: ReactNode;
     items: ActionListItem[];
     groups?: ActionListGroup[];
-    open?: boolean;
     onOpenChange?: (open: boolean) => void;
+    popupRef?: Ref<DropdownPopup | null>;
     align?: DropdownAlign;
     widthMode?: DropdownWidthMode;
     mobileTitle?: ReactNode;
-    filterable?: boolean;
-    filterPlaceholder?: string;
     emptyText?: string;
-    onAction?: ActionListProps['onAction'];
+    onAction?: (item: ActionListItem) => void;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Menu: react.ForwardRefExoticComponent<MenuProps & react.RefAttributes<HTMLDivElement>>;
+declare function Menu({ trigger, children, items, groups, onOpenChange, popupRef: popupRefProp, align, widthMode, mobileTitle, emptyText, onAction, className, tabIndex, 'aria-label': ariaLabel, onContextMenu, onKeyDown, rootRef, ...rest }: MenuProps): React.JSX.Element;
 
 interface ImageGalleryItem {
     src: string;
@@ -689,9 +757,10 @@ interface ImageGalleryProps extends Omit<ComponentPropsWithoutRef<'div'>, 'child
     showThumbnails?: boolean;
     showCounter?: boolean;
     enableKeyboard?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const ImageGallery: react.ForwardRefExoticComponent<ImageGalleryProps & react.RefAttributes<HTMLDivElement>>;
+declare function ImageGallery({ images, index: controlledIndex, defaultIndex, onIndexChange, chrome, showNav, showThumbnails, showCounter, enableKeyboard, className, rootRef, ...rest }: ImageGalleryProps): React.JSX.Element;
 
 interface ImageLightboxProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     open: boolean;
@@ -700,9 +769,10 @@ interface ImageLightboxProps extends Omit<ComponentPropsWithoutRef<'div'>, 'chil
     index?: number;
     defaultIndex?: number;
     onIndexChange?: (index: number) => void;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const ImageLightbox: react.ForwardRefExoticComponent<ImageLightboxProps & react.RefAttributes<HTMLElement>>;
+declare function ImageLightbox({ open, onOpenChange, images, index, defaultIndex, onIndexChange, className, rootRef, ...rest }: ImageLightboxProps): React.JSX.Element;
 
 type LinkVariant = 'primary' | 'secondary' | 'muted';
 type LinkStatus = 'default' | 'danger';
@@ -712,38 +782,41 @@ interface LinkProps extends ComponentPropsWithoutRef<'a'> {
     status?: LinkStatus;
     size?: LinkSize;
     weight?: 'normal' | 'medium' | 'bold';
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const Link: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const Link: ({ variant, status, size, weight, className, children, target, rel, rootRef, ...props }: LinkProps) => React.JSX.Element;
 
 interface SwipeAction {
     id: string;
     label: string;
-    icon?: react__default.ReactNode;
+    icon?: React__default.ReactNode;
     onClick: () => void;
     bg?: string;
     swipeToTrigger?: boolean;
 }
-interface SwipeToActionProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'children'> {
-    children: react__default.ReactNode;
+interface SwipeToActionProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: React__default.ReactNode;
     leftActions?: SwipeAction[];
     rightActions?: SwipeAction[];
     closeOnOutsideClick?: boolean;
     swipeToTriggerThreshold?: number;
     actionWidth?: number;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const SwipeToAction: react__default.ForwardRefExoticComponent<SwipeToActionProps & react__default.RefAttributes<HTMLDivElement>>;
+declare const SwipeToAction: ({ children, leftActions, rightActions, closeOnOutsideClick, swipeToTriggerThreshold, actionWidth, className, style, rootRef, ...rest }: SwipeToActionProps) => React.JSX.Element;
 
 interface MaskedFieldProps extends Omit<TextFieldProps, 'value' | 'onChange'> {
     mask: string;
     value: string;
     onChange: (value: string) => void;
+    inputRef?: Ref<HTMLInputElement>;
     maskAsPlaceholder?: boolean;
 }
 
-declare const MaskedField: react.ForwardRefExoticComponent<Omit<MaskedFieldProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare function MaskedField({ mask, value, onChange, onClear, clearLabel, onKeyDown, disabled, readOnly, maskAsPlaceholder, placeholder: placeholderProp, onClick, inputRef, ...props }: MaskedFieldProps): React.JSX.Element;
 
 interface NumberFieldProps extends Omit<TextFieldProps, 'type' | 'onChange'> {
     value?: number;
@@ -751,68 +824,100 @@ interface NumberFieldProps extends Omit<TextFieldProps, 'type' | 'onChange'> {
     max?: number;
     step?: number;
     onChange?: (val: number | undefined) => void;
+    inputRef?: Ref<HTMLInputElement>;
 }
 
-declare const NumberField: react.ForwardRefExoticComponent<Omit<NumberFieldProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare function NumberField({ value, min, max, step, onChange, onClear, onBlur, clearLabel, postfix: iconEnd, disabled, readOnly, className, inputRef, ...props }: NumberFieldProps): React.JSX.Element;
 
-interface PaginationRootProps extends Omit<react__default.ComponentPropsWithoutRef<'nav'>, 'children'> {
+interface PaginationRootProps extends Omit<React__default.ComponentPropsWithoutRef<'nav'>, 'children'> {
     currentPage: number;
     totalPages: number;
     onPageChange: (page: number) => void;
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
     totalItems?: number;
     pageSize?: number;
     onPageSizeChange?: (pageSize: number) => void;
     pageSizeOptions?: number[];
+    rootRef?: Ref<HTMLElement>;
 }
-interface PaginationSummaryProps extends react__default.HTMLAttributes<HTMLSpanElement> {
+interface PaginationSummaryProps extends React__default.HTMLAttributes<HTMLSpanElement> {
     totalItems?: number;
     pageSize?: number;
+    rootRef?: Ref<HTMLSpanElement>;
 }
-type PaginationControlsProps = react__default.HTMLAttributes<HTMLDivElement>;
-interface PaginationPageSizeProps extends Omit<react__default.HTMLAttributes<HTMLDivElement>, 'children'> {
+type PaginationControlsProps = React__default.HTMLAttributes<HTMLDivElement> & {
+    rootRef?: Ref<HTMLDivElement>;
+};
+interface PaginationPageSizeProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'children'> {
     pageSize: number;
     onPageSizeChange: (pageSize: number) => void;
     pageSizeOptions?: number[];
+    rootRef?: Ref<HTMLDivElement>;
 }
 type PaginationProps = PaginationRootProps;
 
-declare const Pagination: react.ForwardRefExoticComponent<PaginationRootProps & react.RefAttributes<HTMLElement>> & {
-    Summary: react.ForwardRefExoticComponent<PaginationSummaryProps & react.RefAttributes<HTMLSpanElement>>;
-    Controls: react.ForwardRefExoticComponent<PaginationControlsProps & react.RefAttributes<HTMLDivElement>>;
-    PageSize: react.ForwardRefExoticComponent<PaginationPageSizeProps & react.RefAttributes<HTMLDivElement>>;
+declare function PaginationSummary({ totalItems, pageSize, className, rootRef, ...rest }: PaginationSummaryProps): React.JSX.Element | null;
+declare function PaginationControls({ className, rootRef, onClick, ...rest }: PaginationControlsProps): React.JSX.Element;
+declare function PaginationPageSize({ pageSize, onPageSizeChange, pageSizeOptions, className, rootRef, ...rest }: PaginationPageSizeProps): React.JSX.Element;
+declare function PaginationRoot({ currentPage, totalPages, onPageChange, className, children, totalItems, pageSize, onPageSizeChange, pageSizeOptions, 'aria-label': ariaLabel, style, rootRef, ...rest }: PaginationRootProps): React.JSX.Element;
+declare const Pagination: typeof PaginationRoot & {
+    Summary: typeof PaginationSummary;
+    Controls: typeof PaginationControls;
+    PageSize: typeof PaginationPageSize;
 };
 
 type ProgressVariant = 'auto' | 'primary' | 'success' | 'warning' | 'error' | 'info';
 interface ProgressProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     percentage?: number;
     indeterminate?: boolean;
-    label?: react__default.ReactNode;
-    valueText?: react__default.ReactNode;
+    label?: React__default.ReactNode;
+    valueText?: React__default.ReactNode;
     showValueText?: boolean;
     size?: ControlSize;
     variant?: ProgressVariant;
+    rootRef?: Ref<HTMLDivElement>;
 }
 interface ProgressCircleProps extends ProgressProps {
     diameter?: number;
 }
 
-declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
-declare const ProgressCircle: react.ForwardRefExoticComponent<ProgressCircleProps & react.RefAttributes<HTMLDivElement>>;
+declare const Progress: ({ percentage, indeterminate, label, valueText, showValueText, size, variant, className, style, rootRef, ...rest }: ProgressProps) => React.JSX.Element;
+declare const ProgressCircle: ({ percentage, indeterminate, size, diameter, label, valueText, showValueText, variant, className, style, rootRef, ...rest }: ProgressCircleProps) => React.JSX.Element;
+
+type ToggleControlAlign = 'start' | 'center';
+interface ToggleControlBaseProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size' | 'className' | 'style'> {
+    className?: string;
+    style?: CSSProperties;
+    size?: ControlSize;
+    align?: ToggleControlAlign;
+    labelSide?: LabelSide;
+    readOnly?: boolean;
+    label?: ReactNode;
+    labelHidden?: boolean;
+    boxContent?: ReactNode;
+    boxClassName?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    inputRef?: Ref<HTMLInputElement>;
+    labelProps?: Omit<ComponentPropsWithoutRef<'label'>, 'htmlFor' | 'className' | 'style' | 'children'> & Record<`data-${string}`, string | number | boolean | undefined>;
+}
 
 interface RadioProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size'> {
-    label: react__default.ReactNode;
+    label: React__default.ReactNode;
     readOnly?: boolean;
     size?: ControlSize;
     labelSide?: LabelSide;
     onCheckedChange?: (checked: boolean) => void;
+    inputRef?: Ref<HTMLInputElement>;
+    labelProps?: ToggleControlBaseProps['labelProps'];
 }
-interface RadioGroupProps extends Omit<ComponentPropsWithoutRef<'fieldset'>, 'children' | 'onChange'> {
+interface RadioGroupProps extends Omit<ComponentPropsWithoutRef<'fieldset'>, 'children' | 'onChange' | 'defaultValue'> {
     name: string;
     label?: string;
     options: {
         label: string;
         value: string;
+        disabled?: boolean;
     }[];
     value: string;
     onChange: (value: string) => void;
@@ -822,73 +927,40 @@ interface RadioGroupProps extends Omit<ComponentPropsWithoutRef<'fieldset'>, 'ch
     disabled?: boolean;
     size?: ControlSize;
     labelSide?: LabelSide;
+    rootRef?: Ref<HTMLFieldSetElement>;
 }
 
-declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
-declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<HTMLFieldSetElement>>;
-
-type SelectionGroupOrientation = 'horizontal' | 'vertical';
-interface SelectionGroupRootProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'defaultValue' | 'onChange'> {
-    children: react__default.ReactNode;
-    value?: string;
-    defaultValue?: string;
-    onChange?: (value: string) => void;
-    orientation?: SelectionGroupOrientation;
-    disabled?: boolean;
-    readOnly?: boolean;
-    activateOnFocus?: boolean;
-}
-interface SelectionGroupListProps extends ComponentPropsWithoutRef<'div'> {
-    children?: react__default.ReactNode;
-}
-interface SelectionGroupItemProps extends Omit<ComponentPropsWithoutRef<'button'>, 'value'> {
-    value: string;
-    children?: react__default.ReactNode;
-}
-interface SelectionGroupPanelProps extends ComponentPropsWithoutRef<'div'> {
-    value: string;
-    children?: react__default.ReactNode;
-    forceMount?: boolean;
-}
-
-declare const SelectionGroupRoot: ForwardRefExoticComponent<SelectionGroupRootProps & RefAttributes<HTMLDivElement>>;
-declare const SelectionGroupList: ForwardRefExoticComponent<SelectionGroupListProps & RefAttributes<HTMLDivElement>>;
-declare const SelectionGroupItem: ForwardRefExoticComponent<SelectionGroupItemProps & RefAttributes<HTMLButtonElement>>;
-declare const SelectionGroupPanel: ForwardRefExoticComponent<SelectionGroupPanelProps & RefAttributes<HTMLDivElement>>;
-type SelectionGroupComponent = ForwardRefExoticComponent<SelectionGroupRootProps & RefAttributes<HTMLDivElement>> & {
-    Root: typeof SelectionGroupRoot;
-    List: typeof SelectionGroupList;
-    Item: typeof SelectionGroupItem;
-    Panel: typeof SelectionGroupPanel;
-};
-declare const SelectionGroup: SelectionGroupComponent;
+declare const Radio: ({ label, className, disabled, readOnly, size, labelSide, onChange, onCheckedChange, inputRef, labelProps, ...props }: RadioProps) => React.JSX.Element;
+declare const RadioGroup: ({ name, label, options, value, onChange, orientation, readOnly, disabled, size, labelSide, rootRef, className, ...rest }: RadioGroupProps) => React.JSX.Element;
 
 interface SegmentOption<T = string> {
-    label: string;
+    label: ReactNode;
     value: T;
+    disabled?: boolean;
+    id?: string;
+    controls?: string;
 }
 type SegmentedItemFit = ButtonGroupItemFit;
+type SegmentedControlVariant = 'pill' | SurfaceVariant;
 interface SegmentedControlProps<T = string> extends Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'children' | 'defaultValue'> {
     options: SegmentOption<T>[];
     value: T;
     onChange: (value: T) => void;
-    variant?: SurfaceVariant;
+    variant?: SegmentedControlVariant;
     size?: 'sm' | 'md' | 'lg';
     itemFit?: SegmentedItemFit;
+    orientation?: ButtonGroupOrientation;
     readOnly?: boolean;
     disabled?: boolean;
-    borderless?: boolean;
+    width?: 'auto' | 'full';
+    itemRole?: 'tab';
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-type SegmentedControlComponent = (<T extends string | number>(props: SegmentedControlProps<T> & {
-    ref?: Ref<HTMLDivElement>;
-}) => ReactElement) & {
-    displayName?: string;
-};
-declare const SegmentedControl: SegmentedControlComponent;
+declare function SegmentedControl<T extends string | number>({ options, value, onChange, variant, size, itemFit, orientation, readOnly, disabled, width, itemRole, className, onClick, onKeyDown, role, 'aria-label': ariaLabel, rootRef, ...rest }: SegmentedControlProps<T>): React.JSX.Element;
 
-interface SidebarProps extends Omit<react__default.ComponentPropsWithoutRef<'aside'>, 'children' | 'onChange'> {
-    children: react__default.ReactNode;
+interface SidebarProps extends Omit<React__default.ComponentPropsWithoutRef<'aside'>, 'children' | 'onChange'> {
+    children: React__default.ReactNode;
     value?: string;
     defaultValue?: string;
     onChange?: (id: string) => void;
@@ -898,57 +970,56 @@ interface SidebarProps extends Omit<react__default.ComponentPropsWithoutRef<'asi
     mobileDrawer?: boolean;
     mobileOpen?: boolean;
     onMobileOpenChange?: (open: boolean) => void;
+    rootRef?: Ref<HTMLElement>;
 }
-interface SidebarHeaderProps extends react__default.HTMLAttributes<HTMLElement> {
-    children?: react__default.ReactNode;
+interface SidebarHeaderProps extends React__default.HTMLAttributes<HTMLElement> {
+    children?: React__default.ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
-interface SidebarTitleProps extends react__default.HTMLAttributes<HTMLSpanElement> {
-    children: react__default.ReactNode;
+interface SidebarTitleProps extends React__default.HTMLAttributes<HTMLSpanElement> {
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLSpanElement>;
 }
-interface SidebarContentProps extends react__default.HTMLAttributes<HTMLElement> {
-    children: react__default.ReactNode;
+interface SidebarContentProps extends React__default.HTMLAttributes<HTMLElement> {
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
-interface SidebarGroupProps extends react__default.HTMLAttributes<HTMLDivElement> {
-    children: react__default.ReactNode;
+interface SidebarGroupProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
 }
-interface SidebarGroupLabelProps extends react__default.HTMLAttributes<HTMLDivElement> {
-    children: react__default.ReactNode;
+interface SidebarGroupLabelProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
 }
-interface SidebarItemProps extends Omit<react__default.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'type'> {
+interface SidebarItemProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'type'> {
     value: string;
-    icon?: react__default.ReactNode;
-    badge?: react__default.ReactNode;
+    icon?: React__default.ReactNode;
+    badge?: React__default.ReactNode;
     badgeDot?: boolean;
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLButtonElement>;
 }
-interface SidebarFooterProps extends react__default.HTMLAttributes<HTMLElement> {
-    children: react__default.ReactNode;
+interface SidebarFooterProps extends React__default.HTMLAttributes<HTMLElement> {
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
-interface SidebarMobileTriggerProps extends Omit<react__default.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+interface SidebarMobileTriggerProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
     label?: string;
-}
-
-declare const SidebarRoot: react.ForwardRefExoticComponent<SidebarProps & react.RefAttributes<HTMLElement>>;
-declare const SidebarHeader: react.ForwardRefExoticComponent<SidebarHeaderProps & react.RefAttributes<HTMLElement>>;
-declare const SidebarTitle: react.ForwardRefExoticComponent<SidebarTitleProps & react.RefAttributes<HTMLSpanElement>>;
-declare const SidebarContent: react.ForwardRefExoticComponent<SidebarContentProps & react.RefAttributes<HTMLElement>>;
-declare const SidebarGroup: react.ForwardRefExoticComponent<SidebarGroupProps & react.RefAttributes<HTMLDivElement>>;
-declare const SidebarGroupLabel: react.ForwardRefExoticComponent<SidebarGroupLabelProps & react.RefAttributes<HTMLDivElement>>;
-declare const SidebarItem: react.ForwardRefExoticComponent<SidebarItemProps & react.RefAttributes<HTMLButtonElement>>;
-declare const SidebarFooter: react.ForwardRefExoticComponent<SidebarFooterProps & react.RefAttributes<HTMLElement>>;
-declare const SidebarMobileTrigger: react.ForwardRefExoticComponent<SidebarMobileTriggerProps & react.RefAttributes<HTMLButtonElement>>;
-type SidebarComponent = typeof SidebarRoot & {
-    Root: typeof SidebarRoot;
-    Header: typeof SidebarHeader;
-    Title: typeof SidebarTitle;
-    Content: typeof SidebarContent;
-    Group: typeof SidebarGroup;
-    GroupLabel: typeof SidebarGroupLabel;
-    Item: typeof SidebarItem;
-    Footer: typeof SidebarFooter;
-    MobileTrigger: typeof SidebarMobileTrigger;
+    rootRef?: Ref<HTMLButtonElement>;
+}
+
+declare const Sidebar: (({ children, value: controlledActiveId, defaultValue: defaultActiveId, onChange, className, "aria-label": ariaLabel, collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange, mobileDrawer, mobileOpen: controlledMobileOpen, onMobileOpenChange, rootRef, ...rest }: SidebarProps) => React.JSX.Element) & {
+    Root: ({ children, value: controlledActiveId, defaultValue: defaultActiveId, onChange, className, "aria-label": ariaLabel, collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange, mobileDrawer, mobileOpen: controlledMobileOpen, onMobileOpenChange, rootRef, ...rest }: SidebarProps) => React.JSX.Element;
+    Header: ({ className, rootRef, ...rest }: SidebarHeaderProps) => React.JSX.Element;
+    Title: ({ className, rootRef, ...rest }: SidebarTitleProps) => React.JSX.Element;
+    Content: ({ className, rootRef, ...rest }: SidebarContentProps) => React.JSX.Element;
+    Group: ({ className, rootRef, ...rest }: SidebarGroupProps) => React.JSX.Element;
+    GroupLabel: ({ className, rootRef, ...rest }: SidebarGroupLabelProps) => React.JSX.Element;
+    Item: ({ value, icon, badge, badgeDot, children, className, disabled, onClick, rootRef, ...rest }: SidebarItemProps) => React.JSX.Element;
+    Footer: ({ className, rootRef, ...rest }: SidebarFooterProps) => React.JSX.Element;
+    MobileTrigger: ({ label, onClick, rootRef, className, ...rest }: SidebarMobileTriggerProps) => React.JSX.Element;
 };
-declare const Sidebar: SidebarComponent;
 
 type SafeAreaEdges = 'top' | 'right' | 'bottom' | 'left' | 'all' | 'x' | 'y';
 interface SafeAreaProps extends ComponentPropsWithoutRef<'div'> {
@@ -956,31 +1027,33 @@ interface SafeAreaProps extends ComponentPropsWithoutRef<'div'> {
     padding?: string | number;
     fill?: boolean;
     as?: 'div' | 'main' | 'section' | 'header' | 'footer';
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const SafeArea: react.ForwardRefExoticComponent<SafeAreaProps & react.RefAttributes<HTMLElement>>;
+declare const SafeArea: ({ edges, padding, fill, as: Component, children, className, style, rootRef, ...rest }: SafeAreaProps) => React.JSX.Element;
 
 interface PullToRefreshProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     onRefresh: () => void | Promise<void>;
     threshold?: number;
     disabled?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
     pullLabel?: string;
     releaseLabel?: string;
     refreshingLabel?: string;
 }
 
-declare const PullToRefresh: react__default.ForwardRefExoticComponent<PullToRefreshProps & react__default.RefAttributes<HTMLDivElement>>;
+declare const PullToRefresh: ({ children, onRefresh, threshold, disabled, className, pullLabel, releaseLabel, refreshingLabel, onPointerDown, onPointerMove, onPointerUp, onPointerCancel, rootRef, style, ...rest }: PullToRefreshProps) => React.JSX.Element;
 
 type TimelineItemStatus = 'default' | 'success' | 'warning' | 'error' | 'info';
 interface TimelineItem {
     id: string;
-    title: react__default.ReactNode;
-    description?: react__default.ReactNode;
-    details?: react__default.ReactNode;
-    time?: react__default.ReactNode;
-    icon?: react__default.ReactNode;
+    title: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    details?: React__default.ReactNode;
+    time?: React__default.ReactNode;
+    icon?: React__default.ReactNode;
     status?: TimelineItemStatus;
 }
 interface TimelineProps extends Omit<ComponentPropsWithoutRef<'ol'>, 'children'> {
@@ -988,9 +1061,10 @@ interface TimelineProps extends Omit<ComponentPropsWithoutRef<'ol'>, 'children'>
     orientation?: 'vertical' | 'horizontal';
     currentId?: string;
     defaultExpandedIds?: string[];
+    rootRef?: Ref<HTMLOListElement>;
 }
 
-declare const Timeline: react.ForwardRefExoticComponent<TimelineProps & react.RefAttributes<HTMLOListElement>>;
+declare function Timeline({ items, orientation, currentId, defaultExpandedIds, className, rootRef, ...rest }: TimelineProps): React.JSX.Element;
 
 type RangeValue = [number, number];
 type SliderSharedProps = Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'defaultValue'> & {
@@ -1000,6 +1074,7 @@ type SliderSharedProps = Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'def
     disabled?: boolean;
     readOnly?: boolean;
     showValues?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 };
 type SliderSingleProps = SliderSharedProps & {
     value: number;
@@ -1011,36 +1086,38 @@ type SliderRangeProps = SliderSharedProps & {
 };
 type SliderProps = SliderSingleProps | SliderRangeProps;
 
-declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLDivElement>>;
+declare const Slider: ({ min, max, step, disabled, readOnly, showValues, className, style, "aria-label": ariaLabel, value, onChange, rootRef, ...rest }: SliderProps) => React.JSX.Element;
 
 type SpinnerVariant = 'spin' | 'typing' | 'dots' | 'pulse';
 type SpinnerSize = 'sm' | 'md' | 'lg';
 interface SpinnerProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    rootRef?: Ref<HTMLDivElement>;
     variant?: SpinnerVariant;
     size?: number | SpinnerSize;
-    label?: react__default.ReactNode;
+    label?: React__default.ReactNode;
 }
 
-declare const Spinner: react.ForwardRefExoticComponent<SpinnerProps & react.RefAttributes<HTMLDivElement>>;
+declare const Spinner: ({ variant, size, label, className, style, rootRef, "aria-label": ariaLabel, ...rest }: SpinnerProps) => React.JSX.Element;
 
 type StepStatus = 'pending' | 'current' | 'complete' | 'error';
 interface StepItem {
     title: string;
-    description?: react__default.ReactNode;
+    description?: React__default.ReactNode;
     status?: StepStatus;
     disabled?: boolean;
-    icon?: react__default.ReactNode;
+    icon?: React__default.ReactNode;
 }
-interface StepsProps extends Omit<react__default.ComponentPropsWithoutRef<'ol'>, 'children'> {
+interface StepsProps extends Omit<React__default.ComponentPropsWithoutRef<'ol'>, 'children'> {
     currentStep: number;
     items: StepItem[];
     orientation?: 'horizontal' | 'vertical';
     onStepClick?: (index: number) => void;
     size?: 'sm' | 'md' | 'lg';
     showConnectors?: boolean;
+    rootRef?: Ref<HTMLOListElement>;
 }
 
-declare const Steps: react.ForwardRefExoticComponent<StepsProps & react.RefAttributes<HTMLOListElement>>;
+declare const Steps: ({ currentStep, items, orientation, onStepClick, size, showConnectors, className, "aria-label": ariaLabel, rootRef, ...rest }: StepsProps) => React.JSX.Element;
 
 type SwitchLabelSide = LabelSide;
 interface SwitchProps extends Omit<ComponentPropsWithoutRef<'input'>, 'onChange' | 'size'> {
@@ -1052,56 +1129,61 @@ interface SwitchProps extends Omit<ComponentPropsWithoutRef<'input'>, 'onChange'
     readOnly?: boolean;
     size?: ControlSize;
     labelSide?: SwitchLabelSide;
+    inputRef?: Ref<HTMLInputElement>;
 }
 
-declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+declare const Switch: ({ label, checked, onChange, onCheckedChange, className, disabled, readOnly, size, labelSide, inputRef, ...props }: SwitchProps) => React.JSX.Element;
 
 type TabsVariant = 'line' | 'pill';
 type TabsOrientation = 'horizontal' | 'vertical';
+interface TabsItem {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+    badge?: ReactNode;
+    badgeDot?: boolean;
+}
 interface TabsProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange' | 'defaultValue'> {
     value?: string;
     defaultValue?: string;
     onChange?: (id: string) => void;
     variant?: TabsVariant;
     orientation?: TabsOrientation;
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
+}
+interface TabsListProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    items: TabsItem[];
+    rootRef?: Ref<HTMLDivElement>;
 }
-type TabsListProps = ComponentPropsWithoutRef<'div'>;
-interface TabsTriggerProps extends Omit<react__default.ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
+interface TabsTriggerProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
     value: string;
-    badge?: react__default.ReactNode;
+    badge?: React__default.ReactNode;
     badgeDot?: boolean;
 }
-interface TabsPanelProps extends react__default.HTMLAttributes<HTMLDivElement> {
+interface TabsPanelProps extends React__default.HTMLAttributes<HTMLDivElement> {
     value: string;
     forceMount?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const TabsList: react__default.ForwardRefExoticComponent<Omit<react__default.DetailedHTMLProps<react__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react__default.RefAttributes<HTMLDivElement>>;
-declare const TabsTrigger: react__default.ForwardRefExoticComponent<TabsTriggerProps & react__default.RefAttributes<HTMLButtonElement>>;
-declare const TabsPanel: react__default.ForwardRefExoticComponent<TabsPanelProps & react__default.RefAttributes<HTMLDivElement>>;
-declare const TabsRoot: react__default.ForwardRefExoticComponent<TabsProps & react__default.RefAttributes<HTMLDivElement>>;
-type TabsComponent = react__default.ForwardRefExoticComponent<TabsProps & react__default.RefAttributes<HTMLDivElement>> & {
-    Root: typeof TabsRoot;
-    List: typeof TabsList;
-    Trigger: typeof TabsTrigger;
-    Panel: typeof TabsPanel;
+declare const Tabs: (({ value: valueProp, defaultValue, onChange, variant, orientation, className, children, rootRef, ...rest }: TabsProps) => React.JSX.Element) & {
+    Root: ({ value: valueProp, defaultValue, onChange, variant, orientation, className, children, rootRef, ...rest }: TabsProps) => React.JSX.Element;
+    List: ({ className, items, rootRef, ...rest }: TabsListProps) => React.JSX.Element | null;
+    Panel: ({ value, className, children, forceMount: _forceMount, hidden, rootRef, ...rest }: TabsPanelProps) => React.JSX.Element;
 };
-declare const Tabs: TabsComponent;
 
-type TypeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-type TypeWeight = 'normal' | 'medium' | 'semibold' | 'bold';
-interface TypeProps extends ComponentPropsWithoutRef<'span'> {
-    size?: TypeSize;
-    weight?: TypeWeight;
+type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type TextWeight = 'normal' | 'medium' | 'semibold' | 'bold';
+interface TextProps extends Omit<ComponentPropsWithoutRef<'span'>, 'color'> {
+    size?: TextSize;
+    weight?: TextWeight;
     as?: ElementType;
-}
-
-interface TextProps extends Omit<TypeProps, 'color'> {
     color?: 'primary' | 'secondary' | 'tertiary' | 'muted' | 'info' | 'success' | 'warning' | 'error' | 'disabled';
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const Text: react.ForwardRefExoticComponent<TextProps & react.RefAttributes<HTMLElement>>;
+declare const Text: ({ color, size, weight, as, className, rootRef, ...rest }: TextProps) => React.JSX.Element;
 
 type PasswordStrength = 'empty' | 'weak' | 'fair' | 'good' | 'strong';
 interface PasswordFieldProps extends Omit<TextFieldProps, 'type' | 'postfix'> {
@@ -1112,27 +1194,30 @@ interface PasswordFieldProps extends Omit<TextFieldProps, 'type' | 'postfix'> {
     hidePasswordLabel?: string;
     showStrength?: boolean;
     strengthLabels?: Partial<Record<Exclude<PasswordStrength, 'empty'>, string>>;
+    inputRef?: Ref<HTMLInputElement>;
 }
 
 declare function getPasswordStrength(password: string): PasswordStrength;
-declare const PasswordField: react.ForwardRefExoticComponent<Omit<PasswordFieldProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare function PasswordField({ defaultVisible, visible: controlledVisible, onVisibleChange, showPasswordLabel, hidePasswordLabel, showStrength, strengthLabels, value, defaultValue, onChange, description, 'aria-describedby': ariaDescribedBy, id: providedId, inputRef, ...props }: PasswordFieldProps): React.JSX.Element;
 
 type FormMessageVariant = 'error' | 'hint' | 'success';
 interface FormMessageProps extends Omit<ComponentPropsWithoutRef<'p'>, 'color'> {
     variant?: FormMessageVariant;
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLParagraphElement>;
 }
 
-declare const FormMessage: react.ForwardRefExoticComponent<FormMessageProps & react.RefAttributes<HTMLParagraphElement>>;
+declare function FormMessage({ variant, className, role, children, rootRef, ...rest }: FormMessageProps): React.JSX.Element;
 
 interface TextareaFieldProps extends FieldBaseProps, Omit<ComponentPropsWithoutRef<'textarea'>, 'size' | 'width' | 'prefix' | keyof FieldBaseProps> {
     wrapperClassName?: string;
     minRows?: number;
     maxHeight?: number | string;
     autoResize?: boolean;
+    inputRef?: Ref<HTMLTextAreaElement>;
 }
 
-declare const TextareaField: react.ForwardRefExoticComponent<TextareaFieldProps & react.RefAttributes<HTMLTextAreaElement>>;
+declare function TextareaField({ className, wrapperClassName, autoResize, minRows, maxHeight, rows, value, onChange, onClear, style, inputRef, ...props }: TextareaFieldProps): React.JSX.Element;
 
 type Theme = 'light' | 'dark';
 type ThemeApplyTarget = 'wrapper' | 'document';
@@ -1141,7 +1226,8 @@ interface ThemeProviderProps extends Omit<ComponentPropsWithoutRef<'div'>, 'chil
     theme?: Theme;
     onThemeChange?: (theme: Theme) => void;
     applyTo?: ThemeApplyTarget;
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
 interface ThemeContextProps {
@@ -1150,7 +1236,7 @@ interface ThemeContextProps {
     toggleTheme: () => void;
 }
 declare const useTheme: () => ThemeContextProps;
-declare const ThemeProvider: react__default.ForwardRefExoticComponent<ThemeProviderProps & react__default.RefAttributes<HTMLDivElement>>;
+declare const ThemeProvider: ({ initialTheme, theme: themeProp, onThemeChange, applyTo, children, className, rootRef, ...rest }: ThemeProviderProps) => React__default.JSX.Element;
 
 declare const ru: {
     readonly common: {
@@ -1285,6 +1371,7 @@ declare const ru: {
         readonly prev: "Предыдущее изображение";
         readonly next: "Следующее изображение";
         readonly imageN: "Изображение {index}";
+        readonly thumbnails: "Миниатюры";
     };
     readonly imageLightbox: {
         readonly close: "Закрыть галерею";
@@ -1335,6 +1422,7 @@ declare const ru: {
     readonly commandPalette: {
         readonly placeholder: "Поиск команд…";
         readonly title: "Командная палитра";
+        readonly empty: "Ничего не найдено";
     };
     readonly pullToRefresh: {
         readonly pull: "Потяните для обновления";
@@ -1427,14 +1515,15 @@ interface LocaleProviderProps {
     children: ReactNode;
 }
 
-declare const LocaleProvider: react__default.FC<LocaleProviderProps>;
+declare const LocaleProvider: React__default.FC<LocaleProviderProps>;
 
 interface TitleProps extends ComponentPropsWithoutRef<'h2'> {
     level?: 1 | 2 | 3 | 4;
     weight?: 'normal' | 'medium' | 'bold';
+    rootRef?: Ref<HTMLHeadingElement>;
 }
 
-declare const Title: react.ForwardRefExoticComponent<TitleProps & react.RefAttributes<HTMLHeadingElement>>;
+declare const Title: ({ level, weight, className, rootRef, ...rest }: TitleProps) => React.JSX.Element;
 
 type TooltipSide = AnchorSide;
 type TooltipTriggerProps = {
@@ -1447,50 +1536,48 @@ type TooltipBaseProps = {
     className?: string;
     open?: boolean;
     defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
     openDelay?: number;
     closeDelay?: number;
     disabled?: boolean;
+    rootRef?: Ref<HTMLElement>;
     wrap?: boolean;
 };
 type TooltipProps = WithEnrichedChildren<TooltipBaseProps, TooltipTriggerProps>;
 
-declare const Tooltip: react.ForwardRefExoticComponent<{
-    content: ReactNode;
-    side?: TooltipSide;
-    className?: string;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    openDelay?: number;
-    closeDelay?: number;
-    disabled?: boolean;
-    wrap?: boolean;
-} & {
-    children: react.ReactElement<any, string | react.JSXElementConstructor<any>> | RenderChildrenFn<TooltipTriggerProps>;
-} & react.RefAttributes<HTMLElement>>;
+declare const Tooltip: ({ content, side, children, className, disabled, open, defaultOpen, openDelay, closeDelay, wrap: _wrap, rootRef, }: TooltipProps) => string | number | boolean | React.JSX.Element | Iterable<ReactNode> | null | undefined;
 
 interface UploadZoneProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange'> {
     onChange?: (files: FileList) => void;
     multiple?: boolean;
-    children?: react__default.ReactNode | ((openFileDialog: () => void) => react__default.ReactNode);
+    children?: React__default.ReactNode | ((openFileDialog: () => void) => React__default.ReactNode);
     readOnly?: boolean;
     disabled?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const UploadZone: react.ForwardRefExoticComponent<UploadZoneProps & react.RefAttributes<HTMLDivElement>>;
+declare const UploadZone: ({ onChange, multiple, className, children, readOnly, disabled, id, rootRef, ...rest }: UploadZoneProps) => React.JSX.Element;
 
 type SeparatorOrientation = 'horizontal' | 'vertical';
 type SeparatorSpace = SpacingToken | number | string;
 interface SeparatorProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    rootRef?: Ref<HTMLDivElement>;
     orientation?: SeparatorOrientation;
     decorative?: boolean;
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
     start?: SeparatorSpace;
     end?: SeparatorSpace;
 }
 
-declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+declare const Separator: ({ orientation, decorative, children, start, end, className, style, rootRef, ...rest }: SeparatorProps) => React.JSX.Element;
+
+type GapOrientation = 'horizontal' | 'vertical';
+interface GapProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    rootRef?: Ref<HTMLDivElement>;
+    size?: SpacingValue;
+    orientation?: GapOrientation;
+}
+
+declare const Gap: ({ size, orientation, className, style, rootRef, ...rest }: GapProps) => React.JSX.Element;
 
 type AlertVariant = 'info' | 'success' | 'warning' | 'error';
 type AlertLayout = 'block' | 'inline';
@@ -1498,28 +1585,31 @@ interface AlertProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
     variant?: AlertVariant;
     size?: ControlSize;
     layout?: AlertLayout;
-    role?: react__default.AriaRole;
-    title?: react__default.ReactNode;
-    icon?: react__default.ReactNode | null;
-    actions?: react__default.ReactNode;
+    role?: React__default.AriaRole;
+    title?: React__default.ReactNode;
+    icon?: React__default.ReactNode | null;
+    actions?: React__default.ReactNode;
     onClose?: () => void;
     closeLabel?: string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
+declare function Alert({ variant, size, layout, className, role, title, icon, actions, onClose, closeLabel: closeLabelProp, children, rootRef, ...rest }: AlertProps): React.JSX.Element;
 
 interface KbdProps extends ComponentPropsWithoutRef<'kbd'> {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     symbol?: boolean;
+    rootRef?: Ref<HTMLElement>;
 }
 interface KbdGroupProps extends ComponentPropsWithoutRef<'span'> {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
+    rootRef?: Ref<HTMLSpanElement>;
 }
 
-declare const Kbd: react.ForwardRefExoticComponent<KbdProps & react.RefAttributes<HTMLElement>>;
-declare const KbdGroup: react.ForwardRefExoticComponent<KbdGroupProps & react.RefAttributes<HTMLSpanElement>>;
+declare const Kbd: ({ children, symbol, className, rootRef, ...rest }: KbdProps) => React.JSX.Element;
+declare const KbdGroup: ({ children, className, rootRef, ...rest }: KbdGroupProps) => React.JSX.Element;
 
-declare const Item: react.ForwardRefExoticComponent<ItemProps & react.RefAttributes<HTMLDivElement>>;
+declare function Item({ size, variant, interactive, wrap, as, media, mediaVariant, mediaClassName, title, titleClassName, description, descriptionClassName, actions, actionsClassName, className, onClick, role, rootRef, ...rest }: ItemProps): React.JSX.Element;
 
 type BubbleVariant = 'default' | 'outgoing' | 'incoming' | 'system';
 type BubbleAlign = 'start' | 'end';
@@ -1530,129 +1620,33 @@ interface BubbleReaction {
     onClick?: () => void;
 }
 interface BubbleProps extends Omit<ComponentPropsWithoutRef<'div'>, 'content'> {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     variant?: BubbleVariant;
     align?: BubbleAlign;
     group?: 'single' | 'first' | 'middle' | 'last';
-    meta?: react__default.ReactNode;
+    meta?: React__default.ReactNode;
     reactions?: BubbleReaction[];
     collapsible?: boolean;
     collapsedLines?: number;
     expandLabel?: string;
     collapseLabel?: string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Bubble: react.ForwardRefExoticComponent<BubbleProps & react.RefAttributes<HTMLDivElement>>;
+declare const Bubble: ({ children, variant, align, group, meta, reactions, collapsible, collapsedLines, expandLabel, collapseLabel, className, style, rootRef, ...rest }: BubbleProps) => React.JSX.Element;
 
 type MarkerVariant = 'default' | 'separator' | 'note' | 'row';
 interface MarkerProps extends ComponentPropsWithoutRef<'div'> {
-    children?: react__default.ReactNode;
-    icon?: react__default.ReactNode;
+    children?: React__default.ReactNode;
+    icon?: React__default.ReactNode;
     shimmer?: boolean;
     variant?: MarkerVariant;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Marker: react.ForwardRefExoticComponent<MarkerProps & react.RefAttributes<HTMLDivElement>>;
-
-type BackdropVariant = 'default' | 'strong';
-type BackdropBlur = 'none' | 'sm' | 'md';
-type BackdropPosition = 'fixed' | 'absolute';
-interface BackdropProps extends Omit<ComponentPropsWithoutRef<'div'>, 'onClick'> {
-    variant?: BackdropVariant;
-    blur?: BackdropBlur;
-    position?: BackdropPosition;
-    onClick?: () => void;
-    zIndex?: number;
-}
-
-declare const Backdrop: react.ForwardRefExoticComponent<BackdropProps & react.RefAttributes<HTMLDivElement>>;
+declare const Marker: ({ children, icon, shimmer, variant, className, rootRef, ...rest }: MarkerProps) => React.JSX.Element;
 
-type OverlayPurpose = 'tooltip' | 'popover' | 'dropdown' | 'modal' | 'sheet' | 'lightbox' | 'notification';
-
-type OverlayVariant = 'modal' | 'sheet' | 'floating';
-type OverlaySheetSide = 'top' | 'bottom' | 'left' | 'right';
-
-type OverlayDismiss = 'outside' | 'escape' | 'all' | 'none';
-type OverlayContentProps = Omit<react__default.HTMLAttributes<HTMLElement>, 'role' | 'color'> & {
-    role?: string;
-    'aria-modal'?: boolean | 'true' | 'false';
-    'aria-label'?: string;
-    'aria-labelledby'?: string;
-    'aria-describedby'?: string;
-    'data-side'?: AnchorSide;
-    'data-kind'?: OverlayVariant;
-    'data-presented'?: string;
-};
-type OverlayChildren = RenderChildrenFn<OverlayContentProps> | react__default.ReactElement;
-type OverlayBaseProps = {
-    children: OverlayChildren;
-    open: boolean;
-    onOpenChange: (open: boolean) => void;
-    className?: string;
-    purpose?: OverlayPurpose;
-    zIndex?: number | string;
-    'aria-label'?: string;
-    'aria-labelledby'?: string;
-    'aria-describedby'?: string;
-    role?: string;
-};
-type OverlayModalProps = OverlayBaseProps & {
-    variant: 'modal';
-    backdropVariant?: BackdropVariant;
-    backdropBlur?: BackdropBlur;
-};
-type OverlayFloatingProps = OverlayBaseProps & {
-    variant: 'floating';
-    style?: react__default.CSSProperties;
-    backdrop?: boolean;
-    backdropVariant?: BackdropVariant;
-    backdropBlur?: BackdropBlur;
-    dismiss?: OverlayDismiss;
-    lockScroll?: boolean;
-    trapFocus?: boolean;
-};
-type OverlaySheetProps = OverlayBaseProps & {
-    variant: 'sheet';
-    side?: OverlaySheetSide;
-    backdrop?: boolean;
-    backdropVariant?: BackdropVariant;
-    backdropBlur?: BackdropBlur;
-    dismiss?: OverlayDismiss;
-};
-type OverlayProps = OverlayModalProps | OverlayFloatingProps | OverlaySheetProps;
-
-type PopoverTriggerMode = 'click' | 'hover' | 'manual';
-type PopoverContentVariant = 'panel' | 'plain';
-type PopoverTriggerSlotProps = {
-    className?: string;
-    'aria-expanded'?: boolean;
-    'aria-haspopup'?: 'dialog' | 'true';
-    'aria-controls'?: string;
-    'aria-describedby'?: string;
-};
-interface PopoverProps {
-    children?: ReactNode;
-    renderTrigger: RenderChildrenFn<PopoverTriggerSlotProps>;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    trigger?: PopoverTriggerMode;
-    disabled?: boolean;
-    variant?: PopoverContentVariant;
-    className?: string;
-    role?: AriaRole;
-    side?: AnchorSide;
-    align?: AnchorAlign;
-    widthMode?: 'trigger' | 'content' | 'trigger-fit';
-    openDelay?: number;
-    closeDelay?: number;
-    dismiss?: OverlayDismiss;
-}
-
-declare function Popover({ children, renderTrigger, open: controlledOpen, defaultOpen, onOpenChange, trigger, disabled, variant, className, role, side, align, widthMode, openDelay, closeDelay, dismiss, }: PopoverProps): react.JSX.Element;
-declare namespace Popover {
-    var displayName: string;
-}
+declare function Popover({ children, trigger, id, disabled, variant, className, role, side, align, widthMode, popoverTargetAction, defaultOpen, onToggle, panelRef, }: PopoverProps): React.JSX.Element;
 
 interface PopupSwitchOption<T extends string | number = string> {
     value: T;
@@ -1661,12 +1655,13 @@ interface PopupSwitchOption<T extends string | number = string> {
 }
 type PopupSwitchVariant = 'secondary' | 'tinted' | 'ghost';
 type PopupSwitchWidth = 'auto' | 'options';
-type PopupSwitchAlign = 'start' | 'center';
+type PopupSwitchAlign = 'start' | 'center' | 'end';
 interface PopupSwitchProps<T extends string | number = string> {
     value: T;
     options: Array<PopupSwitchOption<T>>;
     onChange: (value: T) => void;
     disabled?: boolean;
+    rootRef?: Ref<HTMLButtonElement>;
     className?: string;
     placeholder?: string;
     size?: ControlSize;
@@ -1676,21 +1671,34 @@ interface PopupSwitchProps<T extends string | number = string> {
     'aria-label'?: string;
 }
 
-declare const PopupSwitch: <T extends string | number = string>(props: PopupSwitchProps<T> & {
-    ref?: react__default.Ref<HTMLButtonElement>;
-}) => react__default.ReactElement;
+declare function PopupSwitch<T extends string | number = string>({ value, options, onChange, disabled, className, placeholder, size, variant, width, align, rootRef, 'aria-label': ariaLabel, }: PopupSwitchProps<T>): React.JSX.Element;
+
+declare function ActionList({ items, groups, className, id: providedId, 'aria-label': ariaLabelProp, onAction, onHighlightChange, filterable, filterPlaceholder, query, onQueryChange, emptyText, rootRef, ...rest }: ActionListProps): React.JSX.Element;
+
+interface ActionItemProps extends Omit<ComponentPropsWithoutRef<'span'>, 'children'> {
+    label: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    shortcut?: ReactNode;
+}
 
-declare const ActionList: react.ForwardRefExoticComponent<ActionListProps & react.RefAttributes<ActionListHandle>>;
+declare function ActionItem({ label, description, icon, shortcut, className, ...rest }: ActionItemProps): React.JSX.Element;
 
 interface ActionSheetTriggerProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    children: react__default.ReactNode;
+    children: ReactNode;
+    items?: ActionListItem[];
+    groups?: ActionListGroup[];
+    onAction?: (item: ActionListItem) => void;
+    onOpenChange?: (open: boolean) => void;
+    mobileTitle?: ReactNode;
     showOverflowTrigger?: boolean;
     longPressMs?: number;
     moveThreshold?: number;
     disabled?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const ActionSheetTrigger: react.ForwardRefExoticComponent<ActionSheetTriggerProps & react.RefAttributes<HTMLDivElement>>;
+declare function ActionSheetTrigger({ children, items, groups, onAction, onOpenChange, mobileTitle, showOverflowTrigger, longPressMs, moveThreshold, disabled, className, rootRef, 'aria-label': ariaLabel, onPointerDown, onPointerMove, onPointerUp, onPointerCancel, onContextMenu, onClick, onAnimationEnd, ...rest }: ActionSheetTriggerProps): React.JSX.Element;
 
 type OverflowDisplay = 'icon' | 'icon-label';
 type OverflowItemDomProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'onClick' | 'type' | 'color'>;
@@ -1720,24 +1728,38 @@ interface OverflowProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'
     maxVisible?: number;
     align?: DropdownAlign;
     moreLabel?: string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const OverflowItem: FC<OverflowItemProps>;
-type OverflowComponent = ForwardRefExoticComponent<OverflowProps & RefAttributes<HTMLDivElement>> & {
-    Item: typeof OverflowItem;
+declare function OverflowRoot(props: OverflowProps): React.JSX.Element;
+declare const Overflow: typeof OverflowRoot & {
+    Item: FC<OverflowItemProps>;
 };
-declare const Overflow: OverflowComponent;
 
 type SelectOption = ListboxOption;
 type SelectSelectionMode = 'single' | 'multiple' | 'path';
+type SelectTriggerMode = 'button' | 'input';
 interface SelectCustomTriggerProps {
     triggerRef: (node: HTMLElement | null) => void;
-    open: boolean;
+    popoverTarget?: string;
+    popoverTargetAction?: PopoverTargetAction;
     listboxId: string;
     activeDescendantId?: string;
+    'aria-expanded'?: boolean;
     chevron: ReactNode;
-    onClick: react__default.MouseEventHandler<HTMLElement>;
-    onKeyDown: react__default.KeyboardEventHandler<HTMLElement>;
+    onClick: React__default.MouseEventHandler<HTMLElement>;
+    onFocus: React__default.FocusEventHandler<HTMLElement>;
+    onKeyDown: React__default.KeyboardEventHandler<HTMLElement>;
+}
+interface SelectSelectionState {
+    value: string | string[];
+    valueArray: string[];
+    selectedOptions: SelectOption[];
+    selectionMode: SelectSelectionMode;
+    hasValue: boolean;
+    isReadOnly: boolean;
+    removeOption: (optionValue: string) => void;
+    clearValue: () => void;
 }
 interface SelectProps extends FieldBaseProps {
     options: SelectOption[];
@@ -1746,7 +1768,6 @@ interface SelectProps extends FieldBaseProps {
     value?: string | string[];
     defaultValue?: string | string[];
     onChange?: (value: string | string[]) => void;
-    open?: boolean;
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
     closeOnSelect?: boolean;
@@ -1760,9 +1781,17 @@ interface SelectProps extends FieldBaseProps {
     popupRole?: 'listbox' | 'tree' | 'dialog' | 'menu';
     filterable?: boolean;
     filterPlaceholder?: string;
+    allowCustom?: boolean;
+    name?: string;
+    required?: boolean;
+    inputRef?: Ref<HTMLInputElement>;
+    onFocus?: React__default.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React__default.FocusEventHandler<HTMLInputElement>;
+    onClick?: React__default.MouseEventHandler<HTMLInputElement>;
+    onKeyDown?: React__default.KeyboardEventHandler<HTMLInputElement>;
     align?: DropdownAlign;
     widthMode?: DropdownWidthMode;
-    triggerMode?: DropdownTriggerMode;
+    triggerMode?: SelectTriggerMode;
     mobileTitle?: ReactNode;
     mobileLeftControls?: ReactNode;
     mobileRightControls?: ReactNode;
@@ -1774,19 +1803,20 @@ interface SelectProps extends FieldBaseProps {
     noOptionsText?: string;
     preventOptionMouseDown?: boolean;
     listAriaLabel?: string;
-    customTrigger?: (props: SelectCustomTriggerProps) => ReactNode;
+    customTrigger?: (triggerProps: SelectCustomTriggerProps, selectionState: SelectSelectionState) => ReactNode;
     onComboboxEnter?: () => void;
     onComboboxEscape?: () => void;
     popupClassName?: string;
+    rootRef?: Ref<HTMLDivElement>;
     className?: string;
     id?: string;
     'aria-label'?: string;
 }
 
-declare const Select: react__default.ForwardRefExoticComponent<SelectProps & react__default.RefAttributes<HTMLDivElement>>;
+declare const Select: ({ options, groups, selectionMode, value: controlledValue, defaultValue, onChange, defaultOpen, onOpenChange, disabled, readOnly, closeOnSelect, filterFn, filterQuery: controlledFilterQuery, defaultFilterQuery, onFilterQueryChange, placeholder, loading, separator, popupRole, filterable, filterPlaceholder, allowCustom, name, required, inputRef, onFocus, onBlur, onClick, onKeyDown, align, widthMode, triggerMode, mobileTitle, mobileLeftControls, mobileRightControls, panelScroll, navigation, highlightedIndex, onHighlightChange, showCheck, noOptionsText: noOptionsTextProp, preventOptionMouseDown, listAriaLabel, customTrigger, onComboboxEnter, onComboboxEscape, popupClassName, rootRef, className, id: providedId, label, size, width, prefix, postfix: _postfix, error, description, onClear, clearLabel, "aria-label": ariaLabel, }: SelectProps) => React.JSX.Element;
 
 type SuggestFieldOption = SelectOption;
-interface SuggestFieldProps extends FieldBaseProps, Omit<react__default.HTMLAttributes<HTMLDivElement>, 'className' | 'onChange' | 'prefix' | 'onFocus' | 'onBlur' | 'onClick' | 'onKeyDown' | keyof FieldBaseProps> {
+interface SuggestFieldProps extends FieldBaseProps {
     options: SuggestFieldOption[];
     value?: string;
     defaultValue?: string;
@@ -1794,46 +1824,113 @@ interface SuggestFieldProps extends FieldBaseProps, Omit<react__default.HTMLAttr
     className?: string;
     name?: string;
     required?: boolean;
-    allowCustom?: boolean;
     filterFn?: ListboxFilterFn<SuggestFieldOption>;
     noOptionsText?: string;
     onChange?: (value: string) => void;
-    onFocus?: react__default.FocusEventHandler<HTMLInputElement>;
-    onBlur?: react__default.FocusEventHandler<HTMLInputElement>;
-    onClick?: react__default.MouseEventHandler<HTMLInputElement>;
-    onKeyDown?: react__default.KeyboardEventHandler<HTMLInputElement>;
+    onFocus?: React__default.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React__default.FocusEventHandler<HTMLInputElement>;
+    onClick?: React__default.MouseEventHandler<HTMLInputElement>;
+    onKeyDown?: React__default.KeyboardEventHandler<HTMLInputElement>;
+    inputRef?: Ref<HTMLInputElement>;
+    id?: string;
+    'aria-label'?: string;
+}
+
+declare const SuggestField: ({ value, defaultValue, onChange, width, noOptionsText, label, "aria-label": ariaLabel, postfix: _postfix, ...props }: SuggestFieldProps) => React.JSX.Element;
+
+type AutocompleteFieldOption = SelectOption;
+interface AutocompleteFieldProps extends FieldBaseProps {
+    options: AutocompleteFieldOption[];
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    className?: string;
+    name?: string;
+    required?: boolean;
+    filterFn?: ListboxFilterFn<AutocompleteFieldOption>;
+    noOptionsText?: string;
+    onChange?: (value: string) => void;
+    onFocus?: React__default.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React__default.FocusEventHandler<HTMLInputElement>;
+    onClick?: React__default.MouseEventHandler<HTMLInputElement>;
+    onKeyDown?: React__default.KeyboardEventHandler<HTMLInputElement>;
+    inputRef?: Ref<HTMLInputElement>;
+    id?: string;
+    'aria-label'?: string;
+}
+
+declare const AutocompleteField: ({ value, defaultValue, onChange, width, noOptionsText, label, "aria-label": ariaLabel, postfix: _postfix, ...props }: AutocompleteFieldProps) => React.JSX.Element;
+
+type MultiSelectOption = SelectOption;
+interface MultiSelectProps extends FieldBaseProps {
+    options: MultiSelectOption[];
+    groups?: ListboxGroup[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    loading?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    closeOnSelect?: boolean;
+    filterFn?: ListboxFilterFn<MultiSelectOption>;
+    filterable?: boolean;
+    filterPlaceholder?: string;
+    filterQuery?: string;
+    defaultFilterQuery?: string;
+    onFilterQueryChange?: (query: string) => void;
+    align?: DropdownAlign;
+    widthMode?: DropdownWidthMode;
+    mobileTitle?: ReactNode;
+    mobileLeftControls?: ReactNode;
+    mobileRightControls?: ReactNode;
+    panelScroll?: DropdownPanelScroll;
+    showCheck?: boolean;
+    noOptionsText?: string;
+    listAriaLabel?: string;
+    popupClassName?: string;
+    rootRef?: Ref<HTMLDivElement>;
+    className?: string;
+    id?: string;
+    'aria-label'?: string;
 }
 
-declare const SuggestField: react.ForwardRefExoticComponent<SuggestFieldProps & react.RefAttributes<HTMLInputElement>>;
+declare const MultiSelect: ({ options, groups, value, defaultValue, onChange, placeholder, loading, disabled, readOnly, label, size, width, prefix, postfix: _postfix, error, description, onClear, clearLabel, className, id: providedId, "aria-label": ariaLabel, listAriaLabel, noOptionsText, filterable, filterPlaceholder, showCheck, ...popupProps }: MultiSelectProps) => React.JSX.Element;
 
+type LayoutNodeRef = Ref<HTMLElement> | Ref<HTMLDivElement> | Ref<HTMLSpanElement> | Ref<HTMLUListElement> | Ref<HTMLOListElement> | Ref<HTMLLIElement>;
 type LayoutGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type LayoutAlign = 'start' | 'center' | 'end' | 'baseline' | 'stretch';
 type LayoutJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
 type LayoutSpacing = 'sm' | 'md' | 'lg';
 interface LayoutRootProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     as?: ElementType;
     padding?: LayoutSpacing;
     gap?: LayoutSpacing;
 }
 interface LayoutHeaderProps extends ComponentPropsWithoutRef<'header'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     sticky?: boolean;
     as?: ElementType;
 }
 interface LayoutContentProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     as?: ElementType;
 }
 type LayoutFooterAlign = 'start' | 'center' | 'end' | 'space-between';
 interface LayoutFooterProps extends Omit<ComponentPropsWithoutRef<'footer'>, 'align'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     sticky?: boolean;
     align?: LayoutFooterAlign;
     as?: ElementType;
 }
 interface StackProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     gap?: LayoutGap;
     align?: LayoutAlign;
     justify?: LayoutJustify;
@@ -1841,6 +1938,7 @@ interface StackProps extends ComponentPropsWithoutRef<'div'> {
 }
 interface InlineProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     gap?: LayoutGap;
     align?: LayoutAlign;
     justify?: LayoutJustify;
@@ -1849,99 +1947,91 @@ interface InlineProps extends ComponentPropsWithoutRef<'div'> {
 }
 interface SplitProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     gap?: LayoutGap;
     align?: LayoutAlign;
 }
 interface LayoutItemProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     grow?: boolean;
     shrink?: boolean;
     as?: 'div' | 'li';
 }
 interface ControlRowProps extends ComponentPropsWithoutRef<'div'> {
     children?: ReactNode;
+    rootRef?: LayoutNodeRef;
     gap?: LayoutGap;
     align?: LayoutAlign;
     justify?: LayoutJustify;
     wrap?: boolean;
 }
 
-declare const LayoutItem: react.ForwardRefExoticComponent<LayoutItemProps & react.RefAttributes<HTMLElement>>;
+declare const LayoutItem: ({ grow, shrink, className, as, rootRef, ...rest }: LayoutItemProps) => React.JSX.Element;
 
-declare const Stack: react.ForwardRefExoticComponent<StackProps & react.RefAttributes<HTMLElement>>;
+declare const Stack: ({ rootRef, gap, align, justify, ...props }: StackProps) => React.JSX.Element;
 
-declare const Inline: react.ForwardRefExoticComponent<InlineProps & react.RefAttributes<HTMLElement>>;
+declare const Inline: ({ rootRef, gap, align, justify, wrap, ...props }: InlineProps) => React.JSX.Element;
 
-declare const Split: react.ForwardRefExoticComponent<SplitProps & react.RefAttributes<HTMLDivElement>>;
+declare const Split: ({ rootRef, gap, align, ...props }: SplitProps) => React.JSX.Element;
 
-type ControlRowComponent = typeof ControlRowInner & {
+type ControlRowComponent = {
+    (props: ControlRowProps): ReactElement;
     Item: typeof LayoutItem;
 };
-declare const ControlRowInner: react.ForwardRefExoticComponent<ControlRowProps & react.RefAttributes<HTMLDivElement>>;
 declare const ControlRow: ControlRowComponent;
 
-declare const LayoutRoot: react.ForwardRefExoticComponent<LayoutRootProps & react.RefAttributes<HTMLElement>>;
-declare const LayoutHeader: react.ForwardRefExoticComponent<LayoutHeaderProps & react.RefAttributes<HTMLElement>>;
-declare const LayoutContent: react.ForwardRefExoticComponent<LayoutContentProps & react.RefAttributes<HTMLElement>>;
-declare const LayoutFooter: react.ForwardRefExoticComponent<LayoutFooterProps & react.RefAttributes<HTMLElement>>;
-declare const Layout: react.ForwardRefExoticComponent<LayoutRootProps & react.RefAttributes<HTMLElement>> & {
-    Header: react.ForwardRefExoticComponent<LayoutHeaderProps & react.RefAttributes<HTMLElement>>;
-    Content: react.ForwardRefExoticComponent<LayoutContentProps & react.RefAttributes<HTMLElement>>;
-    Footer: react.ForwardRefExoticComponent<LayoutFooterProps & react.RefAttributes<HTMLElement>>;
+declare const LayoutRoot: (props: LayoutRootProps) => React.JSX.Element;
+declare const LayoutHeader: ({ as, ...props }: LayoutHeaderProps) => React.JSX.Element;
+declare const LayoutContent: (props: LayoutContentProps) => React.JSX.Element;
+declare const LayoutFooter: ({ as, align, ...props }: LayoutFooterProps) => React.JSX.Element;
+declare const Layout: ((props: LayoutRootProps) => React.JSX.Element) & {
+    Header: ({ as, ...props }: LayoutHeaderProps) => React.JSX.Element;
+    Content: (props: LayoutContentProps) => React.JSX.Element;
+    Footer: ({ as, align, ...props }: LayoutFooterProps) => React.JSX.Element;
 };
 
-interface AdaptiveValue<T> {
-    xs?: T;
-    sm?: T;
-    md?: T;
-    lg?: T;
-    xl?: T;
-}
-declare const GRID_BREAKPOINTS: {
-    readonly xs: 0;
-    readonly sm: 600;
-    readonly md: 768;
-    readonly lg: 1024;
-    readonly xl: 1280;
-};
 type GridGapToken = SpacingToken;
-
 type GridMode = 'fixed' | 'autoFit' | 'autoFill';
 interface GridProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    columns?: number | string | AdaptiveValue<number | string>;
-    gap?: number | string | AdaptiveValue<number | string>;
+    columns?: number | string;
+    gap?: number | string;
     mode?: GridMode;
     minColumnWidth?: number | string;
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     className?: string;
     as?: 'div' | 'section' | 'ul' | 'ol';
+    rootRef?: Ref<HTMLElement>;
 }
 interface GridItemProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    span?: number | AdaptiveValue<number>;
-    colStart?: number | AdaptiveValue<number>;
-    colEnd?: number | AdaptiveValue<number>;
-    rowSpan?: number | AdaptiveValue<number>;
-    children?: react__default.ReactNode;
+    span?: number;
+    colStart?: number;
+    colEnd?: number;
+    rowSpan?: number;
+    children?: React__default.ReactNode;
     className?: string;
     as?: 'div' | 'section' | 'article' | 'aside' | 'li';
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const Grid: react.ForwardRefExoticComponent<GridProps & react.RefAttributes<HTMLElement>>;
-declare const GridItem: react.ForwardRefExoticComponent<GridItemProps & react.RefAttributes<HTMLElement>>;
+declare function Grid({ columns, gap, mode, minColumnWidth, className, style, as: Comp, rootRef, ...rest }: GridProps): React.JSX.Element;
+declare function GridItem({ span, colStart, colEnd, rowSpan, className, style, as: Comp, rootRef, ...rest }: GridItemProps): React.JSX.Element;
 
 type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
 interface ContainerProps extends ComponentPropsWithoutRef<'div'> {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     size?: ContainerSize;
     padded?: boolean;
     as?: 'div' | 'section' | 'main' | 'article';
+    rootRef?: Ref<HTMLElement>;
 }
-interface PageProps extends Omit<ContainerProps, 'as'> {
+interface PageProps extends Omit<ContainerProps, 'as' | 'rootRef'> {
     verticalPadding?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Container: react.ForwardRefExoticComponent<ContainerProps & react.RefAttributes<HTMLElement>>;
-declare const Page: react.ForwardRefExoticComponent<PageProps & react.RefAttributes<HTMLDivElement>>;
+declare function Container({ size, padded, as: Comp, className, style, rootRef, ...rest }: ContainerProps): React.JSX.Element;
+declare function Page({ children, size, padded, verticalPadding, className, style, rootRef, ...rest }: PageProps): React.JSX.Element;
 
 interface DialogLayoutProps extends BoxProps {
     onClose?: () => void;
@@ -1949,7 +2039,7 @@ interface DialogLayoutProps extends BoxProps {
     closeLabel?: string;
 }
 
-declare const DialogLayout: react.ForwardRefExoticComponent<DialogLayoutProps & react.RefAttributes<HTMLElement>>;
+declare const DialogLayout: ({ children, className, onClose, showClose, closeLabel, rootRef, ...rest }: DialogLayoutProps) => React.JSX.Element;
 
 type ModalFooterAlign = 'start' | 'center' | 'end' | 'space-between';
 interface ModalRootProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title' | 'children'> {
@@ -1961,31 +2051,28 @@ interface ModalRootProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title' |
     'aria-labelledby'?: string;
     'aria-label'?: string;
     'aria-describedby'?: string;
+    rootRef?: Ref<HTMLElement>;
 }
 interface ModalHeaderProps extends Omit<ComponentPropsWithoutRef<'header'>, 'children'> {
     children?: ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
 interface ModalBodyProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     children?: ReactNode;
+    rootRef?: Ref<HTMLElement>;
 }
 interface ModalFooterProps extends Omit<ComponentPropsWithoutRef<'footer'>, 'align' | 'children'> {
     children?: ReactNode;
     align?: ModalFooterAlign;
+    rootRef?: Ref<HTMLElement>;
 }
 type ModalProps = ModalRootProps;
 
-declare const ModalHeader: react.ForwardRefExoticComponent<ModalHeaderProps & react.RefAttributes<HTMLElement>>;
-declare const ModalBody: react.ForwardRefExoticComponent<ModalBodyProps & react.RefAttributes<HTMLElement>>;
-declare const ModalFooter: react.ForwardRefExoticComponent<ModalFooterProps & react.RefAttributes<HTMLElement>>;
-declare const ModalRoot: react.ForwardRefExoticComponent<ModalRootProps & react.RefAttributes<HTMLElement>>;
-type ModalComponent = typeof ModalRoot & {
-    Header: typeof ModalHeader;
-    Body: typeof ModalBody;
-    Footer: typeof ModalFooter;
+declare const Modal: (({ open, onOpenChange, children, className, "aria-labelledby": ariaLabelledBy, "aria-label": ariaLabel, "aria-describedby": ariaDescribedBy, rootRef, ...rest }: ModalRootProps) => React.JSX.Element) & {
+    Header: ({ rootRef, ...props }: ModalHeaderProps) => React.JSX.Element;
+    Body: ({ className, rootRef, ...props }: ModalBodyProps) => React.JSX.Element;
+    Footer: ({ align, rootRef, ...props }: ModalFooterProps) => React.JSX.Element;
 };
-declare const Modal: ModalComponent;
-
-type OverlayZIndexTier = 'overlay' | 'modal' | 'dropdown' | 'lightbox' | 'notification';
 
 type SheetMode = 'auto' | 'sidebar' | 'sheet';
 type SheetDirection = 'start' | 'end';
@@ -1997,14 +2084,9 @@ interface SheetProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
     showHandle?: boolean;
     mode?: SheetMode;
     direction?: SheetDirection;
-    backdrop?: boolean;
     width?: number | string;
     height?: number | string;
-    backdropVariant?: 'default' | 'strong';
-    backdropBlur?: 'none' | 'sm' | 'md';
-    zIndexTier?: OverlayZIndexTier;
-    zIndex?: number | string;
-    dismiss?: OverlayDismiss;
+    rootRef?: Ref<HTMLDivElement>;
 }
 interface SheetHeaderProps extends HTMLAttributes<HTMLElement> {
     children?: ReactNode;
@@ -2013,28 +2095,26 @@ interface SheetHeaderProps extends HTMLAttributes<HTMLElement> {
     leftControls?: ReactNode;
     rightControls?: ReactNode;
     showClose?: boolean;
+    rootRef?: Ref<HTMLElement>;
 }
 interface SheetBodyProps extends HTMLAttributes<HTMLElement> {
     children?: ReactNode;
     className?: string;
     padding?: boolean;
+    rootRef?: Ref<HTMLElement>;
 }
 interface SheetFooterProps extends Omit<HTMLAttributes<HTMLElement>, 'align'> {
     children?: ReactNode;
     className?: string;
     align?: SheetFooterAlign;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const SheetHeader: react.ForwardRefExoticComponent<SheetHeaderProps & react.RefAttributes<HTMLElement>>;
-declare const SheetBody: react.ForwardRefExoticComponent<SheetBodyProps & react.RefAttributes<HTMLElement>>;
-declare const SheetFooter: react.ForwardRefExoticComponent<SheetFooterProps & react.RefAttributes<HTMLElement>>;
-declare const SheetRoot: react.ForwardRefExoticComponent<SheetProps & react.RefAttributes<HTMLDivElement>>;
-type SheetComponent = typeof SheetRoot & {
-    Header: typeof SheetHeader;
-    Body: typeof SheetBody;
-    Footer: typeof SheetFooter;
+declare const Sheet: (({ open, onOpenChange, children, showHandle, mode, direction, width, height, className, style, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, rootRef, ...rest }: SheetProps) => React.JSX.Element) & {
+    Header: ({ children, className, variant, leftControls, rightControls, showClose: showCloseProp, rootRef, ...rest }: SheetHeaderProps) => React.JSX.Element;
+    Body: ({ className, padding, rootRef, ...rest }: SheetBodyProps) => React.JSX.Element;
+    Footer: ({ className, align, rootRef, ...rest }: SheetFooterProps) => React.JSX.Element;
 };
-declare const Sheet: SheetComponent;
 
 interface ConfirmDialogSecondaryAction {
     label: string;
@@ -2045,7 +2125,7 @@ interface ConfirmDialogSecondaryAction {
 interface ConfirmDialogProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title' | 'children'> {
     open: boolean;
     title: string;
-    message: react__default.ReactNode;
+    message: React__default.ReactNode;
     confirmLabel?: string;
     cancelLabel?: string;
     status?: 'default' | 'danger';
@@ -2053,11 +2133,46 @@ interface ConfirmDialogProps extends Omit<ComponentPropsWithoutRef<'div'>, 'titl
     onConfirm: () => void;
     onOpenChange: (open: boolean) => void;
     loading?: boolean;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const ConfirmDialog: react.ForwardRefExoticComponent<ConfirmDialogProps & react.RefAttributes<HTMLElement>>;
+declare function ConfirmDialog({ open, title, message, confirmLabel: confirmLabelProp, cancelLabel: cancelLabelProp, status, secondaryAction, onConfirm, onOpenChange, loading, className, id, rootRef, ...rest }: ConfirmDialogProps): React.JSX.Element;
 
-declare const Overlay: react.ForwardRefExoticComponent<OverlayProps & react.RefAttributes<HTMLElement>>;
+type OverlayVariant = 'modal' | 'sheet' | 'floating';
+type OverlaySheetSide = 'top' | 'bottom' | 'left' | 'right';
+type OverlayBaseProps = {
+    children: React__default.ReactNode;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    className?: string;
+    hostClassName?: string;
+    style?: React__default.CSSProperties;
+    rootRef?: React__default.Ref<HTMLElement>;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    role?: string;
+};
+type OverlayModalProps = OverlayBaseProps & {
+    variant?: 'modal';
+    side?: never;
+};
+type OverlayFloatingProps = Omit<OverlayBaseProps, 'open' | 'onOpenChange'> & {
+    variant: 'floating';
+    side?: never;
+    id?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    'data-side'?: string;
+    'data-width-mode'?: string;
+};
+type OverlaySheetProps = OverlayBaseProps & {
+    variant: 'sheet';
+    side?: OverlaySheetSide;
+};
+type OverlayProps = OverlayModalProps | OverlayFloatingProps | OverlaySheetProps;
+
+declare function Overlay(props: OverlayProps): React.JSX.Element;
 
 interface CommandPaletteProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'title' | 'onSelect'> {
     open: boolean;
@@ -2070,9 +2185,10 @@ interface CommandPaletteProps extends Omit<ComponentPropsWithoutRef<'div'>, 'chi
     footer?: ReactNode;
     onAction?: (item: ActionListItem) => void;
     className?: string;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const CommandPalette: react.ForwardRefExoticComponent<CommandPaletteProps & react.RefAttributes<HTMLElement>>;
+declare function CommandPalette({ open, onOpenChange, items, groups, title: titleProp, placeholder, emptyText, footer, onAction, className, id, style, rootRef, ...rest }: CommandPaletteProps): React.JSX.Element;
 
 interface CalendarDayCell {
     day: number;
@@ -2108,17 +2224,25 @@ interface CalendarProviderProps {
     onChange?: (value: Date | DateRangeValue) => void;
     viewDate?: Date;
     onViewDateChange?: (date: Date) => void;
-    renderDayCell?: (props: CalendarDayCellRenderProps) => react__default.ReactNode;
-    children: react__default.ReactNode;
+    renderDayCell?: (props: CalendarDayCellRenderProps) => React__default.ReactNode;
+    children: React__default.ReactNode;
 }
-type CalendarRootProps = react__default.ComponentPropsWithoutRef<'div'>;
-type CalendarHeaderProps = react__default.ComponentPropsWithoutRef<'div'>;
-type CalendarTitleProps = react__default.ComponentPropsWithoutRef<'span'>;
-interface CalendarNavProps extends Omit<react__default.ComponentPropsWithoutRef<'button'>, 'direction'> {
+type CalendarRootProps = React__default.ComponentPropsWithoutRef<'div'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
+type CalendarHeaderProps = React__default.ComponentPropsWithoutRef<'div'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
+type CalendarTitleProps = React__default.ComponentPropsWithoutRef<'span'> & {
+    rootRef?: React__default.Ref<HTMLSpanElement>;
+};
+interface CalendarNavProps extends Omit<React__default.ComponentPropsWithoutRef<'button'>, 'direction'> {
     direction: 'prev' | 'next';
+    rootRef?: React__default.Ref<HTMLButtonElement>;
 }
-interface CalendarBodyProps extends react__default.ComponentPropsWithoutRef<'div'> {
-    renderDayCell?: (props: CalendarDayCellRenderProps) => react__default.ReactNode;
+interface CalendarBodyProps extends React__default.ComponentPropsWithoutRef<'div'> {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+    renderDayCell?: (props: CalendarDayCellRenderProps) => React__default.ReactNode;
 }
 type CalendarContextValue = {
     selectionMode: CalendarSelectionMode;
@@ -2136,26 +2260,25 @@ type CalendarContextValue = {
     shiftView: (delta: number) => void;
     selectMonth: (monthIndex: number) => void;
     selectYear: (year: number) => void;
-    renderDayCell?: (props: CalendarDayCellRenderProps) => react__default.ReactNode;
+    renderDayCell?: (props: CalendarDayCellRenderProps) => React__default.ReactNode;
 };
 
 declare const Calendar: {
-    Provider: react.FC<CalendarProviderProps>;
-    Root: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    Header: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    Title: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
-    Nav: react.ForwardRefExoticComponent<CalendarNavProps & react.RefAttributes<HTMLButtonElement>>;
-    Body: react.ForwardRefExoticComponent<CalendarBodyProps & react.RefAttributes<HTMLDivElement>>;
-} & {
-    displayName: string;
+    Provider: React.FC<CalendarProviderProps>;
+    Root: ({ className, children, onClick, rootRef, ...rest }: CalendarRootProps) => React.JSX.Element;
+    Header: ({ className, children, rootRef, ...rest }: CalendarHeaderProps) => React.JSX.Element;
+    Title: ({ className, rootRef, ...rest }: CalendarTitleProps) => React.JSX.Element;
+    Nav: ({ direction, className, "aria-label": ariaLabel, onClick, rootRef, ...rest }: CalendarNavProps) => React.JSX.Element;
+    Body: ({ className, renderDayCell: renderDayCellProp, rootRef, ...rest }: CalendarBodyProps) => React.JSX.Element;
 };
 
 interface DateFieldProps extends Omit<MaskedFieldProps, 'mask' | 'value' | 'onChange' | 'active'> {
     value: Date | undefined;
     onChange: (date: Date | undefined) => void;
+    inputRef?: Ref<HTMLInputElement>;
 }
 
-declare const DateField: react.ForwardRefExoticComponent<Omit<DateFieldProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare function DateField({ value, onChange, label, width, disabled, readOnly, prefix, onClear, onClick, onFocus, inputRef, ...rest }: DateFieldProps): React.JSX.Element;
 
 interface DateRangeFieldProps extends Omit<FieldBaseProps, 'label'>, Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'defaultValue' | 'children' | keyof FieldBaseProps> {
     value: DateRangeValue;
@@ -2164,9 +2287,11 @@ interface DateRangeFieldProps extends Omit<FieldBaseProps, 'label'>, Omit<Compon
     startLabel?: string;
     endLabel?: string;
     layout?: 'single' | 'split';
+    rootRef?: Ref<HTMLDivElement>;
+    inputRef?: Ref<HTMLInputElement>;
 }
 
-declare const DateRangeField: react.ForwardRefExoticComponent<DateRangeFieldProps & react.RefAttributes<HTMLInputElement>>;
+declare function DateRangeField({ value, onChange, label, startLabel, endLabel, layout, size, width, className, disabled, readOnly, error, description, prefix, postfix, onClear, clearLabel, rootRef, inputRef, ...rest }: DateRangeFieldProps): React.JSX.Element;
 
 interface DayStripDayRenderProps {
     date: Date;
@@ -2175,7 +2300,7 @@ interface DayStripDayRenderProps {
     isSelected: boolean;
     isToday: boolean;
 }
-interface DayStripCalendarProps extends Omit<react__default.ComponentPropsWithoutRef<'div'>, 'onChange'> {
+interface DayStripCalendarProps extends Omit<React__default.ComponentPropsWithoutRef<'div'>, 'onChange'> {
     value?: Date;
     onChange: (date: Date) => void;
     viewDate?: Date;
@@ -2184,16 +2309,17 @@ interface DayStripCalendarProps extends Omit<react__default.ComponentPropsWithou
     weekStartsOn?: 0 | 1;
     showHeader?: boolean;
     showNav?: boolean;
-    renderDay?: (props: DayStripDayRenderProps) => react__default.ReactNode;
+    renderDay?: (props: DayStripDayRenderProps) => React__default.ReactNode;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const DayStripCalendar: react__default.ForwardRefExoticComponent<DayStripCalendarProps & react__default.RefAttributes<HTMLDivElement>>;
+declare function DayStripCalendar({ value, onChange, viewDate: controlledViewDate, onViewDateChange, daysCount, weekStartsOn, showHeader, showNav, className, 'aria-label': ariaLabel, renderDay, rootRef, ...rest }: DayStripCalendarProps): React.JSX.Element;
 
 interface TimeFieldProps extends Omit<MaskedFieldProps, 'mask'> {
     value: string;
 }
 
-declare const TimeField: react.ForwardRefExoticComponent<Omit<TimeFieldProps, "ref"> & react.RefAttributes<HTMLInputElement>>;
+declare function TimeField({ value, onChange, label, disabled, readOnly, prefix, onFocus, onClick, onKeyDown, className, inputRef, ...props }: TimeFieldProps): React.JSX.Element;
 
 type TimeValue = {
     hours: number;
@@ -2205,9 +2331,10 @@ type TimePopupProps = {
 };
 interface WheelTimePickerProps extends TimePopupProps, Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'defaultValue'> {
     active?: boolean;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const WheelTimePicker: react.ForwardRefExoticComponent<WheelTimePickerProps & react.RefAttributes<HTMLDivElement>>;
+declare const WheelTimePicker: ({ value, onChange, active, className, rootRef, ...rest }: WheelTimePickerProps) => React.JSX.Element;
 
 interface ChartSeries {
     name: string;
@@ -2217,6 +2344,7 @@ interface ChartSeries {
 
 type BarChartDataset = ChartSeries;
 interface BarChartProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    rootRef?: Ref<HTMLDivElement>;
     categories: string[];
     datasets: BarChartDataset[];
     height?: number;
@@ -2224,18 +2352,19 @@ interface BarChartProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'
     showHoverValue?: boolean;
 }
 
-declare const BarChart: react.ForwardRefExoticComponent<BarChartProps & react.RefAttributes<HTMLDivElement>>;
+declare const BarChart: ({ categories, datasets, height, className, showValues, showHoverValue, rootRef, ...rest }: BarChartProps) => React.JSX.Element;
 
 interface ChartDataset extends ChartSeries {
     color: string;
 }
 interface LineChartProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    rootRef?: Ref<HTMLDivElement>;
     categories: string[];
     datasets: ChartDataset[];
     height?: number;
 }
 
-declare const LineChart: react.ForwardRefExoticComponent<LineChartProps & react.RefAttributes<HTMLDivElement>>;
+declare const LineChart: ({ categories, datasets, height, className, rootRef, ...rest }: LineChartProps) => React.JSX.Element;
 
 interface DonutSegment {
     id?: string;
@@ -2244,23 +2373,24 @@ interface DonutSegment {
     color?: string;
 }
 interface DonutChartProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    rootRef?: Ref<HTMLDivElement>;
     segments: DonutSegment[];
     size?: number;
     thickness?: number;
-    centerLabel?: react__default.ReactNode;
-    centerValue?: react__default.ReactNode;
+    centerLabel?: React__default.ReactNode;
+    centerValue?: React__default.ReactNode;
     showLegend?: boolean;
     hoverExpand?: boolean;
 }
 
-declare const DonutChart: react.ForwardRefExoticComponent<DonutChartProps & react.RefAttributes<HTMLDivElement>>;
+declare const DonutChart: ({ segments, size, thickness, centerLabel, centerValue, className, showLegend, hoverExpand, rootRef, style, ...rest }: DonutChartProps) => React.JSX.Element;
 
 interface NotificationAction {
     label: string;
     onClick: () => void;
     variant?: 'primary' | 'secondary';
     shortcut?: string;
-    shortcutLabel?: react__default.ReactNode;
+    shortcutLabel?: React__default.ReactNode;
 }
 interface NotificationItem {
     id: string;
@@ -2274,33 +2404,35 @@ interface NotificationItem {
 }
 type NotificationPosition = 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
 interface NotificationViewportProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
     stacked?: boolean;
     stackDepth?: number;
     position?: NotificationPosition;
+    rootRef?: Ref<HTMLDivElement>;
 }
 interface NotificationProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
-    title: react__default.ReactNode;
-    description?: react__default.ReactNode;
+    title: React__default.ReactNode;
+    description?: React__default.ReactNode;
     actions?: NotificationAction[];
     variant?: NotificationItem['variant'];
     duration?: number;
     progress?: boolean;
     pauseOnHover?: boolean;
-    onClose?: () => void;
+    onClose?: (id?: string) => void;
+    rootRef?: Ref<HTMLDivElement>;
 }
 type NotifyInput = Omit<NotificationItem, 'id'> & {
     id?: string;
 };
 interface NotificationProviderProps {
-    children?: react__default.ReactNode;
+    children?: React__default.ReactNode;
     maxVisible?: number;
     stacked?: boolean;
     stackDepth?: number;
     position?: NotificationPosition;
 }
 
-type NotifyShortcut = (title: string, description?: string, rest?: Omit<NotifyInput, 'title' | 'description' | 'type'>) => string;
+type NotifyShortcut = (title: string, description?: string, rest?: Omit<NotifyInput, 'title' | 'description'>) => string;
 interface NotifyFn {
     (input: NotifyInput | string): string;
     info: NotifyShortcut;
@@ -2313,26 +2445,29 @@ interface NotifyFn {
 declare function dismiss(id: string): void;
 declare function dismissAll(): void;
 declare const notify: NotifyFn;
+
+declare function NotificationViewport({ children, stacked, stackDepth: _stackDepth, position, className, rootRef, ...rest }: NotificationViewportProps): React.JSX.Element;
+declare function NotificationCard({ variant, duration, progress, pauseOnHover, onClose, title, description, actions, className, style, rootRef, onAnimationEnd, ...rest }: NotificationProps): React.JSX.Element;
+type NotificationComponent = typeof NotificationCard & {
+    Provider: (props: NotificationProviderProps) => ReactNode;
+    Viewport: typeof NotificationViewport;
+};
+declare const Notification: NotificationComponent;
+
 interface ToastContextValue {
     notify: NotifyFn;
-    dismiss: typeof dismiss;
-    dismissAll: typeof dismissAll;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
 }
-declare const NotificationProvider: react__default.FC<NotificationProviderProps>;
+declare const NotificationProvider: React__default.FC<NotificationProviderProps>;
 declare function useNotify(): ToastContextValue;
 
-declare const NotificationViewport: react__default.ForwardRefExoticComponent<NotificationViewportProps & react__default.RefAttributes<HTMLDivElement>>;
-declare const Notification: react__default.ForwardRefExoticComponent<NotificationProps & react__default.RefAttributes<HTMLDivElement>> & {
-    Provider: react__default.FC<NotificationProviderProps>;
-    Viewport: typeof NotificationViewport;
-};
-
 type TableSortDirection = 'asc' | 'desc';
 type TableDensity = Density;
 interface Column<T> {
     key: keyof T | string;
     header: string;
-    render?: (row: T) => react__default.ReactNode;
+    render?: (row: T) => React__default.ReactNode;
     sortable?: boolean;
     sticky?: 'left' | 'right';
     resizable?: boolean;
@@ -2366,7 +2501,7 @@ interface TableProps<T> extends Omit<ComponentPropsWithoutRef<'div'>, 'children'
     onSortChange?: (key: string, direction: TableSortDirection) => void;
     expandedKeys?: Set<string | number>;
     onExpandedChange?: (keys: Set<string | number>) => void;
-    renderExpandedRow?: (row: T) => react__default.ReactNode;
+    renderExpandedRow?: (row: T) => React__default.ReactNode;
     rowActions?: (row: T) => ActionListItem[];
     rowActionsLabel?: string;
     toolbar?: ReactNode;
@@ -2374,18 +2509,20 @@ interface TableProps<T> extends Omit<ComponentPropsWithoutRef<'div'>, 'children'
     loadingRows?: number;
     empty?: ReactNode | TableEmptyConfig;
     footer?: TablePagination;
+    virtualized?: boolean;
+    estimateRowSize?: number;
+    rootRef?: Ref<HTMLDivElement>;
 }
 interface TableRowActionsProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     items: ActionListItem[];
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const Table: <T extends object>(props: TableProps<T> & {
-    ref?: react__default.Ref<HTMLDivElement>;
-}) => react__default.ReactElement;
+declare function Table<T extends object>({ columns, data, rowKey, rowActions, rowActionsLabel, toolbar, loading, loadingRows, empty, footer, className, 'aria-label': ariaLabel, stickyHeader, selectedKeys, onSelectionChange, density, sortKey, sortDirection, onSortChange, expandedKeys, onExpandedChange, renderExpandedRow, virtualized, estimateRowSize, rootRef, ...rest }: TableProps<T>): React.JSX.Element;
 
 interface SortableItem {
     id: string;
-    content: react__default.ReactNode;
+    content: React__default.ReactNode;
 }
 type SortableListVariant = 'default' | 'plain';
 interface SortableListProps<T extends {
@@ -2393,25 +2530,27 @@ interface SortableListProps<T extends {
 } = SortableItem> extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
     items: T[];
     onOrderChange: (newItems: T[]) => void;
-    renderItem?: (item: T, index: number) => react__default.ReactNode;
+    renderItem?: (item: T, index: number) => React__default.ReactNode;
     variant?: SortableListVariant;
     keyboardReorder?: boolean;
     showMoveButtons?: boolean;
     showDragHandle?: boolean;
     handleOnly?: boolean;
+    estimateSize?: number;
+    virtualThreshold?: number;
+    height?: number | string;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const SortableList: <T extends {
+declare function SortableList<T extends {
     id: string;
-} = SortableItem>(props: SortableListProps<T> & {
-    ref?: react__default.Ref<HTMLDivElement>;
-}) => react__default.ReactElement;
+} = SortableItem>({ items, onOrderChange, renderItem, variant, className, style, keyboardReorder, showMoveButtons, showDragHandle, handleOnly, estimateSize, virtualThreshold, height, rootRef, onPointerDown, onKeyDown, onClick, 'aria-describedby': ariaDescribedBy, ...rest }: SortableListProps<T>): React.JSX.Element;
 
 type VirtualListAlign = 'start' | 'center' | 'end' | 'auto';
 interface VirtualListRenderItemInfo<T> {
     item: T;
     index: number;
-    style: react__default.CSSProperties;
+    style?: React__default.CSSProperties;
 }
 interface VirtualListRange {
     start: number;
@@ -2445,19 +2584,20 @@ interface VirtualListProps<T> extends Omit<ComponentPropsWithoutRef<'div'>, 'chi
     height?: number | string;
     gap?: number;
     getItemKey?: (item: T, index: number) => string | number;
-    renderItem: (info: VirtualListRenderItemInfo<T>) => react__default.ReactNode;
-    onScroll?: (event: Event | react__default.UIEvent<HTMLDivElement>) => void;
+    renderItem: (info: VirtualListRenderItemInfo<T>) => React__default.ReactNode;
+    onScroll?: (event: Event | React__default.UIEvent<HTMLDivElement>) => void;
     onRangeChange?: (range: VirtualListRange) => void;
     onRangeChangeOptions?: VirtualListOnRangeChangeOptions;
-    scrollElement?: HTMLElement | null | react__default.RefObject<HTMLElement | null>;
+    scrollElement?: HTMLElement | null | React__default.RefObject<HTMLElement | null>;
     useWindowScroll?: boolean;
     scrollMetrics?: VirtualScrollMetrics;
     scrollMetricsStore?: VirtualScrollMetricsStore;
+    itemWrapper?: boolean;
+    controlRef?: MutableRefObject<VirtualListHandle | null>;
+    rootRef?: Ref<HTMLDivElement>;
 }
 
-declare const VirtualList: <T>(props: VirtualListProps<T> & {
-    ref?: react__default.Ref<VirtualListHandle>;
-}) => react__default.ReactElement | null;
+declare const VirtualList: <T>({ items, estimateSize, overscan, height, gap, getItemKey, renderItem, itemWrapper, className, style, onScroll, onRangeChange, onRangeChangeOptions, "aria-label": ariaLabel, scrollElement, useWindowScroll, scrollMetrics, scrollMetricsStore, controlRef, rootRef, ...rest }: VirtualListProps<T>) => React.JSX.Element;
 
 type ImageCropShape = 'circle' | 'square';
 
@@ -2478,9 +2618,10 @@ interface ImageCropProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children
     confirmLabel?: string;
     cancelLabel?: string;
     onCrop?: (result: ImageCropResult) => void;
+    rootRef?: Ref<HTMLElement>;
 }
 
-declare const ImageCrop: react__default.ForwardRefExoticComponent<ImageCropProps & react__default.RefAttributes<HTMLElement>>;
+declare function ImageCrop({ open, onOpenChange, file, src, shape, cropSize, outputSize, title, confirmLabel, cancelLabel, className, style, onCrop, onClick, rootRef, ...rest }: ImageCropProps): React.JSX.Element;
 
 type CalendarBoardView = 'month' | 'week' | 'day' | 'year';
 type CalendarBoardTask = CalendarScheduleEvent & {
@@ -2498,7 +2639,7 @@ interface CalendarBoardTaskRenderProps {
     onMouseEnter?: () => void;
     onMouseLeave?: () => void;
     className?: string;
-    style?: react__default.CSSProperties;
+    style?: React__default.CSSProperties;
 }
 interface CalendarBoardDayCellRenderProps {
     date: Date;
@@ -2528,12 +2669,12 @@ interface CalendarBoardContextValue {
     dayEndHour: number;
     hourHeight: number;
     onTaskClick?: (task: CalendarBoardTask) => void;
-    renderTask?: (props: CalendarBoardTaskRenderProps) => react__default.ReactNode;
-    renderDayCell?: (props: CalendarBoardDayCellRenderProps) => react__default.ReactNode;
-    renderYearMonth?: (props: CalendarBoardYearMonthRenderProps) => react__default.ReactNode;
+    renderTask?: (props: CalendarBoardTaskRenderProps) => React__default.ReactNode;
+    renderDayCell?: (props: CalendarBoardDayCellRenderProps) => React__default.ReactNode;
+    renderYearMonth?: (props: CalendarBoardYearMonthRenderProps) => React__default.ReactNode;
 }
 interface CalendarBoardProviderProps {
-    children: react__default.ReactNode;
+    children: React__default.ReactNode;
     view?: CalendarBoardView;
     defaultView?: CalendarBoardView;
     onViewChange?: (view: CalendarBoardView) => void;
@@ -2548,44 +2689,60 @@ interface CalendarBoardProviderProps {
     dayEndHour?: number;
     hourHeight?: number;
     onTaskClick?: (task: CalendarBoardTask) => void;
-    renderTask?: (props: CalendarBoardTaskRenderProps) => react__default.ReactNode;
-    renderDayCell?: (props: CalendarBoardDayCellRenderProps) => react__default.ReactNode;
-    renderYearMonth?: (props: CalendarBoardYearMonthRenderProps) => react__default.ReactNode;
+    renderTask?: (props: CalendarBoardTaskRenderProps) => React__default.ReactNode;
+    renderDayCell?: (props: CalendarBoardDayCellRenderProps) => React__default.ReactNode;
+    renderYearMonth?: (props: CalendarBoardYearMonthRenderProps) => React__default.ReactNode;
 }
-interface CalendarBoardTaskChipProps extends Omit<react__default.ComponentPropsWithoutRef<'div'>, 'children'> {
+interface CalendarBoardTaskChipProps extends Omit<React__default.ComponentPropsWithoutRef<'div'>, 'children'> {
     task: CalendarBoardTask;
     layout?: CalendarBoardTaskLayout;
     continuesBefore?: boolean;
     continuesAfter?: boolean;
     timeLabel?: string;
     highlighted?: boolean;
+    rootRef?: React__default.Ref<HTMLElement>;
 }
-interface CalendarBoardMonthProps extends react__default.ComponentPropsWithoutRef<'div'> {
+interface CalendarBoardMonthProps extends React__default.ComponentPropsWithoutRef<'div'> {
     maxChipsPerDay?: number;
+    rootRef?: React__default.Ref<HTMLDivElement>;
 }
-interface CalendarBoardWeekProps extends react__default.ComponentPropsWithoutRef<'div'> {
+interface CalendarBoardWeekProps extends React__default.ComponentPropsWithoutRef<'div'> {
     showScheduleHeader?: boolean;
     showScheduleNav?: boolean;
+    rootRef?: React__default.Ref<HTMLDivElement>;
 }
-interface CalendarBoardDayProps extends react__default.ComponentPropsWithoutRef<'div'> {
+interface CalendarBoardDayProps extends React__default.ComponentPropsWithoutRef<'div'> {
     showScheduleHeader?: boolean;
     showScheduleNav?: boolean;
+    rootRef?: React__default.Ref<HTMLDivElement>;
 }
-type CalendarBoardYearProps = react__default.ComponentPropsWithoutRef<'div'>;
-interface CalendarBoardBodyProps extends react__default.ComponentPropsWithoutRef<'div'> {
+type CalendarBoardYearProps = React__default.ComponentPropsWithoutRef<'div'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
+interface CalendarBoardBodyProps extends React__default.ComponentPropsWithoutRef<'div'> {
+    rootRef?: React__default.Ref<HTMLDivElement>;
     monthProps?: CalendarBoardMonthProps;
     weekProps?: CalendarBoardWeekProps;
     dayProps?: CalendarBoardDayProps;
     yearProps?: CalendarBoardYearProps;
 }
-interface CalendarBoardViewSwitchProps extends react__default.ComponentPropsWithoutRef<'div'> {
+interface CalendarBoardViewSwitchProps extends React__default.ComponentPropsWithoutRef<'div'> {
     variant?: 'primary' | 'tinted' | 'secondary';
     size?: 'sm' | 'md' | 'lg';
+    rootRef?: React__default.Ref<HTMLDivElement>;
 }
-type CalendarBoardRootProps = react__default.ComponentPropsWithoutRef<'div'>;
-type CalendarBoardHeaderProps = react__default.ComponentPropsWithoutRef<'div'>;
-type CalendarBoardTitleProps = react__default.ComponentPropsWithoutRef<'div'>;
-type CalendarBoardNavProps = react__default.ComponentPropsWithoutRef<'div'>;
+type CalendarBoardRootProps = React__default.ComponentPropsWithoutRef<'div'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
+type CalendarBoardHeaderProps = React__default.ComponentPropsWithoutRef<'div'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
+type CalendarBoardTitleProps = Omit<React__default.ComponentPropsWithoutRef<'div'>, 'color'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
+type CalendarBoardNavProps = React__default.ComponentPropsWithoutRef<'div'> & {
+    rootRef?: React__default.Ref<HTMLDivElement>;
+};
 
 declare function useCalendarBoardTaskHover(taskId: string): {
     highlighted: boolean;
@@ -2594,20 +2751,20 @@ declare function useCalendarBoardTaskHover(taskId: string): {
 };
 declare function useCalendarBoardContext(): CalendarBoardContextValue;
 
-declare const CalendarBoard: react.FC<CalendarBoardProviderProps> & {
-    Provider: react.FC<CalendarBoardProviderProps>;
-    Root: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    Header: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    Title: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    Nav: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    ViewSwitch: react.ForwardRefExoticComponent<CalendarBoardViewSwitchProps & react.RefAttributes<HTMLDivElement>>;
-    Body: react.ForwardRefExoticComponent<CalendarBoardBodyProps & react.RefAttributes<HTMLDivElement>>;
-    Month: react.ForwardRefExoticComponent<CalendarBoardMonthProps & react.RefAttributes<HTMLDivElement>>;
-    Week: react.ForwardRefExoticComponent<CalendarBoardWeekProps & react.RefAttributes<HTMLDivElement>>;
-    Day: react.ForwardRefExoticComponent<CalendarBoardDayProps & react.RefAttributes<HTMLDivElement>>;
-    Year: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
-    TaskChip: react.ForwardRefExoticComponent<CalendarBoardTaskChipProps & react.RefAttributes<HTMLButtonElement | HTMLSpanElement>>;
+declare const CalendarBoard: (({ children, view: controlledView, defaultView, onViewChange, viewDate: controlledViewDate, defaultViewDate, onViewDateChange, selectedDate: controlledSelectedDate, onSelectedDateChange, tasks, weekStartsOn, dayStartHour, dayEndHour, hourHeight, onTaskClick, renderTask, renderDayCell, renderYearMonth, }: CalendarBoardProviderProps) => React.JSX.Element) & {
+    Provider: ({ children, view: controlledView, defaultView, onViewChange, viewDate: controlledViewDate, defaultViewDate, onViewDateChange, selectedDate: controlledSelectedDate, onSelectedDateChange, tasks, weekStartsOn, dayStartHour, dayEndHour, hourHeight, onTaskClick, renderTask, renderDayCell, renderYearMonth, }: CalendarBoardProviderProps) => React.JSX.Element;
+    Root: ({ children, className, style, rootRef, "aria-label": ariaLabel, ...rest }: CalendarBoardRootProps) => React.JSX.Element;
+    Header: ({ children, className, rootRef, ...rest }: CalendarBoardHeaderProps) => React.JSX.Element;
+    Title: ({ className, rootRef, ...rest }: CalendarBoardTitleProps) => React.JSX.Element;
+    Nav: ({ className, rootRef, ...rest }: CalendarBoardNavProps) => React.JSX.Element;
+    ViewSwitch: ({ className, variant, size, rootRef, ...rest }: CalendarBoardViewSwitchProps) => React.JSX.Element;
+    Body: ({ className, monthProps, weekProps, dayProps, yearProps, rootRef, ...rest }: CalendarBoardBodyProps) => React.JSX.Element;
+    Month: ({ className, maxChipsPerDay, rootRef, ...rest }: CalendarBoardMonthProps) => React.JSX.Element;
+    Week: ({ className, showScheduleHeader, showScheduleNav, rootRef, ...rest }: CalendarBoardWeekProps) => React.JSX.Element;
+    Day: ({ className, showScheduleHeader, showScheduleNav, rootRef, ...rest }: CalendarBoardDayProps) => React.JSX.Element;
+    Year: ({ className, rootRef, ...rest }: CalendarBoardYearProps) => React.JSX.Element;
+    TaskChip: ({ task, layout, continuesBefore, continuesAfter, timeLabel, className, style, highlighted: highlightedProp, rootRef, ...rest }: CalendarBoardTaskChipProps) => string | number | boolean | React.JSX.Element | Iterable<React.ReactNode> | null | undefined;
 };
 
-export { Accordion, ActionList, ActionSheetTrigger, Alert, AspectRatio, Attachment, Avatar, AvatarGroup, Backdrop, Badge, BarChart, Box, Bubble, Button, ButtonGroup, ButtonIcon, Calendar, CalendarBoard, Card, Checkbox, CheckboxGroup, Chip, ChipGroup, Collapse, ColorSwatchGroup, CommandPalette, ConfirmDialog, Container, ControlRow, DateField, DateRangeField, DayStripCalendar, DescriptionList, DialogLayout, DonutChart, Dropdown, EmptyState, FieldBaseButton, FieldBaseIcon, FieldGroup, FieldLabel, Fieldset, FileList$1 as FileList, FormMessage, GRID_BREAKPOINTS, Grid, GridItem, ImageCrop, ImageGallery, ImageLightbox, Inline, Item, Kbd, KbdGroup, Layout, LayoutContent, LayoutFooter, LayoutHeader, LayoutItem, LayoutRoot, LineChart, Link, Listbox, LiveRegion, LocaleProvider, Marker, MaskedField, Media, Menu, Modal, Notification, NotificationProvider, NumberField, Overflow, Overlay, Page, Pagination, PasswordField, PinInput, Popover, PopupSwitch, Progress, ProgressCircle, PullToRefresh, Radio, RadioGroup, Rating, RelativeTime, SafeArea, ScrollArea, SearchField, SegmentedControl, Select, SelectionGroup, Separator, Sheet, Sidebar, Skeleton, SkipLink, Slider, SortableList, Spinner, Split, Stack, StatBadge, Steps, SuggestField, SwipeToAction, Switch, Table, Tabs, Text, TextField, TextareaField, ThemeProvider, TimeField, Timeline, Title, Tooltip, UploadZone, VirtualList, VisuallyHidden, WheelTimePicker, dismiss, dismissAll, en, formatRelativeTime, getPasswordStrength, notify, ru, useCalendarBoardContext, useCalendarBoardTaskHover, useLocale, useNotify, useT, useTheme };
-export type { AccordionItemProps, AccordionProps, AccordionVariant, ActionListGroup, ActionListHandle, ActionListItem, ActionListProps, ActionSheetTriggerProps, AdaptiveValue, AlertLayout, AlertProps, AlertVariant, AspectRatioProps, AttachmentProps, AttachmentSize, AttachmentStatus, AvatarGroupProps, AvatarProps, AvatarSize, AvatarStatus, BackdropBlur, BackdropPosition, BackdropProps, BackdropVariant, BadgePosition, BadgeProps, BadgeSize, BadgeVariant, BarChartDataset, BarChartProps, BoxAs, BoxBorderStyle, BoxPadding, BoxProps, BoxRadius, BoxShadow, BoxVariant, BubbleAlign, BubbleProps, BubbleReaction, BubbleVariant, ButtonGroupItemFit, ButtonGroupItemProps, ButtonGroupMode, ButtonGroupRootProps, ButtonGroupVariant, ButtonIconProps, ButtonProps, ButtonVariant, CalendarBoardBodyProps, CalendarBoardDayCellRenderProps, CalendarBoardDayProps, CalendarBoardHeaderProps, CalendarBoardMonthProps, CalendarBoardNavProps, CalendarBoardProviderProps, CalendarBoardRootProps, CalendarBoardTask, CalendarBoardTaskChipProps, CalendarBoardTaskLayout, CalendarBoardTaskRenderProps, CalendarBoardTitleProps, CalendarBoardView, CalendarBoardWeekProps, CalendarBoardYearMonthRenderProps, CalendarBoardYearProps, CalendarBodyProps, CalendarContextValue, CalendarDayCell, CalendarDayCellRenderProps, CalendarHeaderProps, CalendarNavProps, CalendarProviderProps, CalendarRootProps, CalendarScheduleEvent, CalendarSelectionMode, CalendarTitleProps, CalendarViewMode, CardProps, CardVariant, CheckboxGroupProps, CheckboxMode, CheckboxProps, ChipGroupGap, ChipGroupProps, ChipMode, ChipProps, ChipVariant, CollapseProps, ColorSwatchGroupProps, Column, ActionListGroup as CommandPaletteGroup, ActionListItem as CommandPaletteItem, CommandPaletteProps, ConfirmDialogProps, ConfirmDialogSecondaryAction, ContainerProps, ContainerSize, ControlRowProps, ControlSize, DateFieldProps, DateRangeFieldProps, DateRangeValue, DayStripCalendarProps, DayStripDayRenderProps, DeepPartialMessages, DescriptionListItem, DescriptionListProps, DialogLayoutProps, DonutChartProps, DropdownAlign, DropdownPanelScroll, DropdownPopupRole, DropdownProps, DropdownTriggerAttrs, DropdownTriggerMode, DropdownTriggerSlotProps, DropdownWidthMode, EmptyStateProps, EmptyStateSize, FieldBaseButtonProps, FieldBaseIconProps, FieldBaseProps, FieldGroupProps, FieldGroupWidth, FieldLabelAlign, FieldLabelJustify, FieldLabelLayout, FieldLabelProps, FieldWidth, FieldsetProps, FieldsetVariant, FileListItemProps, FileListItemStatus, FileListRootProps, FormMessageProps, FormMessageVariant, GridGapToken, GridItemProps, GridMode, GridProps, ImageCropProps, ImageCropResult, ImageCropShape, ImageGalleryItem, ImageGalleryProps, ImageLightboxProps, InlineProps, ItemMediaVariant, ItemProps, ItemSize, ItemVariant, KbdGroupProps, KbdProps, LabelSide, LayoutAlign, LayoutContentProps, LayoutFooterAlign, LayoutFooterProps, LayoutGap, LayoutHeaderProps, LayoutItemProps, LayoutJustify, LayoutRootProps, LayoutSpacing, LineChartProps, LinkProps, LinkSize, LinkStatus, LinkVariant, ListboxFilterFn, ListboxGroup, ListboxHandle, ListboxNavigation, ListboxOption, ListboxProps, LiveRegionProps, LocaleCode, LocaleProviderProps, MarkerProps, MarkerVariant, MaskedFieldProps, MediaProps, MenuProps, MenuTrigger, Messages, ModalBodyProps, ModalFooterAlign, ModalFooterProps, ModalHeaderProps, ModalProps, ModalRootProps, NotificationAction, NotificationItem, NotificationPosition, NotificationProps, NotificationProviderProps, NotificationViewportProps, NotifyInput, NumberFieldProps, OverflowDisplay, OverflowFit, OverflowGap, OverflowItemProps, OverflowProps, OverlayBaseProps, OverlayChildren, OverlayContentProps, OverlayDismiss, OverlayFloatingProps, OverlayModalProps, OverlayProps, OverlayPurpose, OverlaySheetProps, OverlaySheetSide, OverlayVariant, PageProps, PaginationControlsProps, PaginationPageSizeProps, PaginationProps, PaginationRootProps, PaginationSummaryProps, PasswordFieldProps, PasswordStrength, PinInputProps, PopoverContentVariant, PopoverProps, PopoverTriggerMode, PopoverTriggerSlotProps, PopupSwitchAlign, PopupSwitchOption, PopupSwitchProps, PopupSwitchVariant, PopupSwitchWidth, ProgressCircleProps, ProgressProps, ProgressVariant, PullToRefreshProps, RadioGroupProps, RadioProps, RangeValue, RatingProps, RelativeTimeProps, ResolvedListboxGroup, SafeAreaEdges, SafeAreaProps, ScrollAreaProps, SearchFieldProps, SegmentOption, SegmentedControlProps, SegmentedItemFit, SelectCustomTriggerProps, SelectOption, SelectProps, SelectionGroupItemProps, SelectionGroupListProps, SelectionGroupOrientation, SelectionGroupPanelProps, SelectionGroupRootProps, SeparatorOrientation, SeparatorProps, SeparatorSpace, SheetBodyProps, SheetDirection, SheetFooterAlign, SheetFooterProps, SheetHeaderProps, SheetMode, SheetProps, SidebarContentProps, SidebarFooterProps, SidebarGroupLabelProps, SidebarGroupProps, SidebarHeaderProps, SidebarItemProps, SidebarMobileTriggerProps, SidebarProps, SidebarTitleProps, SkeletonProps, SkeletonVariant, SkipLinkProps, SliderProps, SliderRangeProps, SliderSingleProps, SortableItem, SortableListProps, SortableListVariant, SpinnerProps, SpinnerSize, SpinnerVariant, SplitProps, StackProps, StatBadgeProps, StepItem, StepStatus, StepsProps, SuggestFieldOption, SuggestFieldProps, SwipeAction, SwipeToActionProps, SwitchLabelSide, SwitchProps, TableDensity, TableEmptyConfig, TablePagination, TableProps, TableRowActionsProps, TableSortDirection, TabsListProps, TabsOrientation, TabsPanelProps, TabsProps, TabsTriggerProps, TabsVariant, TextFieldAs, TextFieldProps, TextFieldRef, TextProps, TextareaFieldProps, Theme, ThemeApplyTarget, ThemeProviderProps, TimeFieldProps, TimePopupProps, TimeValue, TimelineItem, TimelineItemStatus, TimelineProps, TitleProps, TooltipProps, TooltipSide, TooltipTriggerProps, TranslationParams, UploadZoneProps, VirtualListAlign, VirtualListHandle, VirtualListOnRangeChangeOptions, VirtualListProps, VirtualListRange, VirtualListRenderItemInfo, VirtualScrollMetrics, VirtualScrollMetricsStore, VisuallyHiddenProps, WheelTimePickerProps };
+export { Accordion, ActionItem, ActionList, ActionSheetTrigger, Alert, AspectRatio, Attachment, AutocompleteField, Avatar, AvatarGroup, Badge, BarChart, Box, Bubble, Button, ButtonGroup, ButtonIcon, Calendar, CalendarBoard, Card, Checkbox, CheckboxGroup, Chip, ChipGroup, Collapse, ColorSwatchGroup, CommandPalette, ConfirmDialog, Container, ControlRow, DateField, DateRangeField, DayStripCalendar, DescriptionList, DialogLayout, DonutChart, Dropdown, EmptyState, FieldBaseButton, FieldBaseIcon, FieldGroup, FieldLabel, Fieldset, FileList$1 as FileList, FileUploader, FormMessage, Gap, Grid, GridItem, ImageCrop, ImageGallery, ImageLightbox, Inline, Item, Kbd, KbdGroup, Layout, LayoutContent, LayoutFooter, LayoutHeader, LayoutItem, LayoutRoot, LineChart, Link, Listbox, LiveRegion, LocaleProvider, Marker, MaskedField, Media, Menu, Modal, MultiSelect, Notification, NotificationProvider, NumberField, Overflow, Overlay, Page, Pagination, PasswordField, PinInput, Popover, PopupSwitch, Progress, ProgressCircle, PullToRefresh, Radio, RadioGroup, Rating, RelativeTime, SafeArea, ScrollArea, SearchField, SegmentedControl, Select, Separator, Sheet, Sidebar, Skeleton, SkipLink, Slider, SortableList, Spinner, Split, Stack, StatBadge, Steps, SuggestField, SwipeToAction, Switch, Table, Tabs, Text, TextField, TextareaField, ThemeProvider, TimeField, Timeline, Title, Tooltip, UploadZone, VirtualList, VisuallyHidden, WheelTimePicker, dismiss, dismissAll, en, formatRelativeTime, getPasswordStrength, notify, ru, useCalendarBoardContext, useCalendarBoardTaskHover, useLocale, useNotify, useT, useTheme };
+export type { AccordionItemData, AccordionItemProps, AccordionProps, AccordionVariant, ActionItemProps, ActionListGroup, ActionListItem, ActionListProps, ActionSheetTriggerProps, AlertLayout, AlertProps, AlertVariant, AspectRatioProps, AttachmentProps, AttachmentSize, AttachmentStatus, AutocompleteFieldOption, AutocompleteFieldProps, AvatarGroupProps, AvatarProps, AvatarSize, AvatarStatus, BadgePosition, BadgeProps, BadgeSize, BadgeVariant, BarChartDataset, BarChartProps, BoxAs, BoxBorderStyle, BoxProps, BoxRadius, BoxShadow, BoxVariant, BubbleAlign, BubbleProps, BubbleReaction, BubbleVariant, ButtonGroupItemFit, ButtonGroupOrientation, ButtonGroupRootProps, ButtonGroupVariant, ButtonIconProps, ButtonProps, ButtonVariant, CalendarBoardBodyProps, CalendarBoardDayCellRenderProps, CalendarBoardDayProps, CalendarBoardHeaderProps, CalendarBoardMonthProps, CalendarBoardNavProps, CalendarBoardProviderProps, CalendarBoardRootProps, CalendarBoardTask, CalendarBoardTaskChipProps, CalendarBoardTaskLayout, CalendarBoardTaskRenderProps, CalendarBoardTitleProps, CalendarBoardView, CalendarBoardWeekProps, CalendarBoardYearMonthRenderProps, CalendarBoardYearProps, CalendarBodyProps, CalendarContextValue, CalendarDayCell, CalendarDayCellRenderProps, CalendarHeaderProps, CalendarNavProps, CalendarProviderProps, CalendarRootProps, CalendarScheduleEvent, CalendarSelectionMode, CalendarTitleProps, CalendarViewMode, CardProps, CardVariant, CheckboxGroupProps, CheckboxMode, CheckboxProps, ChipGroupGap, ChipGroupProps, ChipMode, ChipProps, ChipVariant, CollapseProps, ColorSwatchGroupProps, Column, ActionListGroup as CommandPaletteGroup, ActionListItem as CommandPaletteItem, CommandPaletteProps, ConfirmDialogProps, ConfirmDialogSecondaryAction, ContainerProps, ContainerSize, ControlRowProps, ControlSize, DateFieldProps, DateRangeFieldProps, DateRangeValue, DayStripCalendarProps, DayStripDayRenderProps, DeepPartialMessages, DescriptionListItem, DescriptionListProps, DialogLayoutProps, DonutChartProps, DropdownAlign, DropdownPanelScroll, DropdownPanelState, DropdownPopup, DropdownPopupRole, DropdownProps, DropdownTriggerAttrs, DropdownTriggerMode, DropdownTriggerSlotProps, DropdownWidthMode, EmptyStateProps, EmptyStateSize, FieldBaseButtonProps, FieldBaseIconProps, FieldBaseProps, FieldGroupProps, FieldGroupWidth, FieldLabelAlign, FieldLabelJustify, FieldLabelLayout, FieldLabelProps, FieldWidth, FieldsetProps, FieldsetVariant, FileListItemProps, FileListItemStatus, FileListRootProps, FileUploaderFile, FileUploaderProps, FormMessageProps, FormMessageVariant, GapOrientation, GapProps, GridGapToken, GridItemProps, GridMode, GridProps, ImageCropProps, ImageCropResult, ImageCropShape, ImageGalleryItem, ImageGalleryProps, ImageLightboxProps, InlineProps, ItemMediaVariant, ItemProps, ItemSize, ItemVariant, KbdGroupProps, KbdProps, LabelSide, LayoutAlign, LayoutContentProps, LayoutFooterAlign, LayoutFooterProps, LayoutGap, LayoutHeaderProps, LayoutItemProps, LayoutJustify, LayoutRootProps, LayoutSpacing, LineChartProps, LinkProps, LinkSize, LinkStatus, LinkVariant, ListboxEntry, ListboxFilterFn, ListboxGroup, ListboxHandle, ListboxNavigation, ListboxOption, ListboxProps, ListboxSeparator, LiveRegionProps, LocaleCode, LocaleProviderProps, MarkerProps, MarkerVariant, MaskedFieldProps, MediaProps, MenuProps, MenuTrigger, Messages, ModalBodyProps, ModalFooterAlign, ModalFooterProps, ModalHeaderProps, ModalProps, ModalRootProps, MultiSelectOption, MultiSelectProps, NotificationAction, NotificationItem, NotificationPosition, NotificationProps, NotificationProviderProps, NotificationViewportProps, NotifyInput, NumberFieldProps, OverflowDisplay, OverflowFit, OverflowGap, OverflowItemProps, OverflowProps, OverlayBaseProps, OverlayFloatingProps, OverlayModalProps, OverlayProps, OverlaySheetProps, OverlaySheetSide, OverlayVariant, PageProps, PaginationControlsProps, PaginationPageSizeProps, PaginationProps, PaginationRootProps, PaginationSummaryProps, PasswordFieldProps, PasswordStrength, PinInputProps, PopoverContentVariant, PopoverProps, PopoverTargetAction, PopoverTriggerSlotProps, PopupSwitchAlign, PopupSwitchOption, PopupSwitchProps, PopupSwitchVariant, PopupSwitchWidth, ProgressCircleProps, ProgressProps, ProgressVariant, PullToRefreshProps, RadioGroupProps, RadioProps, RangeValue, RatingProps, RelativeTimeProps, ResolvedListboxGroup, SafeAreaEdges, SafeAreaProps, ScrollAreaProps, SearchFieldProps, SegmentOption, SegmentedControlProps, SegmentedControlVariant, SegmentedItemFit, SelectCustomTriggerProps, SelectOption, SelectProps, SelectSelectionMode, SelectSelectionState, SelectTriggerMode, SeparatorOrientation, SeparatorProps, SeparatorSpace, SheetBodyProps, SheetDirection, SheetFooterAlign, SheetFooterProps, SheetHeaderProps, SheetMode, SheetProps, SidebarContentProps, SidebarFooterProps, SidebarGroupLabelProps, SidebarGroupProps, SidebarHeaderProps, SidebarItemProps, SidebarMobileTriggerProps, SidebarProps, SidebarTitleProps, SkeletonProps, SkeletonVariant, SkipLinkProps, SliderProps, SliderRangeProps, SliderSingleProps, SortableItem, SortableListProps, SortableListVariant, SpinnerProps, SpinnerSize, SpinnerVariant, SplitProps, StackProps, StatBadgeProps, StepItem, StepStatus, StepsProps, SuggestFieldOption, SuggestFieldProps, SwipeAction, SwipeToActionProps, SwitchLabelSide, SwitchProps, TableDensity, TableEmptyConfig, TablePagination, TableProps, TableRowActionsProps, TableSortDirection, TabsItem, TabsListProps, TabsOrientation, TabsPanelProps, TabsProps, TabsTriggerProps, TabsVariant, TextFieldAs, TextFieldProps, TextFieldRef, TextProps, TextareaFieldProps, Theme, ThemeApplyTarget, ThemeProviderProps, TimeFieldProps, TimePopupProps, TimeValue, TimelineItem, TimelineItemStatus, TimelineProps, TitleProps, TooltipProps, TooltipSide, TooltipTriggerProps, TranslationParams, UploadZoneProps, VirtualListAlign, VirtualListHandle, VirtualListOnRangeChangeOptions, VirtualListProps, VirtualListRange, VirtualListRenderItemInfo, VirtualScrollMetrics, VirtualScrollMetricsStore, VisuallyHiddenProps, WheelTimePickerProps };