@boxcustodia/library 2.0.0-alpha.12 → 2.0.0-alpha.14

package/dist/index.d.ts

@@ -1,51 +1,59 @@
+import { Accordion as AccordionPrimitive } from '@base-ui/react/accordion';
 import { AlertDialog as AlertDialogPrimitive } from '@base-ui/react/alert-dialog';
+import { Autocomplete as AutocompletePrimitive } from '@base-ui/react/autocomplete';
 import { Avatar as AvatarPrimitive } from '@base-ui/react/avatar';
-import { ButtonHTMLAttributes } from 'react';
+import { Button as Button_2 } from '@base-ui/react/button';
 import { ChangeEvent } from 'react';
 import { CheckboxGroup as CheckboxGroup_3 } from '@base-ui/react/checkbox-group';
 import { Checkbox as CheckboxPrimitive } from '@base-ui/react/checkbox';
 import { ClassNameValue } from 'tailwind-merge';
 import { ClassProp } from 'class-variance-authority/types';
 import { ClassValue } from 'clsx';
-import { Collection } from 'react-aria-components';
 import { Combobox as ComboboxPrimitive } from '@base-ui/react/combobox';
-import { Command } from 'cmdk';
 import { ComponentProps } from 'react';
 import { ComponentPropsWithoutRef } from 'react';
+import { ComponentType } from 'react';
+import { ControllerRenderProps } from 'react-hook-form';
 import { CSSProperties } from 'react';
 import { DayPicker } from 'react-day-picker';
 import { default as default_2 } from 'react';
 import { DependencyList } from 'react';
 import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
-import { DialogProps as DialogProps_2 } from '@radix-ui/react-dialog';
 import { Dispatch } from 'react';
-import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 import { ElementType } from 'react';
+import { FieldPath } from 'react-hook-form';
 import { Field as FieldPrimitive } from '@base-ui/react/field';
+import { Fieldset as FieldsetPrimitive } from '@base-ui/react/fieldset';
+import { FieldValues } from 'react-hook-form';
 import { FormEvent } from 'react';
 import { Form as FormPrimitive } from '@base-ui/react/form';
 import { HTMLAttributes } from 'react';
 import { HTMLProps } from 'react';
 import { Input as InputPrimitive } from '@base-ui/react/input';
+import { ItemInstance } from '@headless-tree/core';
 import { JSX } from 'react/jsx-runtime';
+import { JSXElementConstructor } from 'react';
 import { ListIterateeCustom } from 'lodash';
 import { LucideIcon } from 'lucide-react';
 import { LucideProps } from 'lucide-react';
+import { Menu as Menu_2 } from '@base-ui/react/menu';
 import { MutableRefObject } from 'react';
 import { NumberField as NumberInputPrimitive } from '@base-ui/react/number-field';
 import { Popover as PopoverPrimitive } from '@base-ui/react/popover';
-import { Presence } from '@radix-ui/react-presence';
 import { Progress as Progress_2 } from '@base-ui/react/progress';
 import * as React_2 from 'react';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
 import { RefObject } from 'react';
+import { RegisterOptions } from 'react-hook-form';
 import { ScrollArea as ScrollAreaPrimitive } from '@base-ui/react/scroll-area';
 import { Select as SelectPrimitive } from '@base-ui/react/select';
+import { Separator as SeparatorPrimitive } from '@base-ui/react/separator';
 import { SetStateAction } from 'react';
-import { Slot } from '@radix-ui/react-slot';
+import { SubmitHandler } from 'react-hook-form';
 import { Switch as Switch_2 } from '@base-ui/react/switch';
+import { Tabs as TabsPrimitive } from '@base-ui/react/tabs';
 import { ToastManager } from '@base-ui/react';
 import { ToastManagerAddOptions as ToastManagerAddOptions_2 } from '@base-ui/react/toast';
 import { ToastManagerPromiseOptions } from '@base-ui/react';
@@ -53,12 +61,49 @@ import { ToastManagerUpdateOptions } from '@base-ui/react';
 import { ToastObject } from '@base-ui/react/toast';
 import { Toast as ToastPrimitive } from '@base-ui/react/toast';
 import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
-import { TreeItemContent as TreeItemContent_2 } from 'react-aria-components';
-import { TreeItemProps } from 'react-aria-components';
-import { TreeProps } from 'react-aria-components';
+import { TreeInstance } from '@headless-tree/core';
 import { useControllableState } from '@radix-ui/react-use-controllable-state';
+import { UseFormProps } from 'react-hook-form';
+import { UseFormReturn } from 'react-hook-form';
 import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
+import { z } from 'zod';
+
+export declare function Accordion({ items, className, classNames, ...props }: AccordionProps): JSX.Element;
+
+export declare function AccordionContent({ className, children, ...props }: AccordionPrimitive.Panel.Props): JSX.Element;
+
+export declare function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props): JSX.Element;
+
+declare function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props): JSX.Element;
+
+declare interface AccordionItem_2 {
+    value: string;
+    trigger: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+
+export { AccordionPrimitive }
+
+declare interface AccordionProps extends Omit<AccordionPrimitive.Root.Props, "children" | "className"> {
+    items: AccordionItem_2[];
+    /** Styles the accordion root container. */
+    className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Each collapsible item wrapper. */
+        item?: string;
+        /** Trigger button that toggles the item. */
+        trigger?: string;
+        /** Panel that contains the item content. */
+        content?: string;
+    };
+}
+
+export declare function AccordionRoot({ className, ...props }: AccordionPrimitive.Root.Props): JSX.Element;
+
+export declare function AccordionTrigger({ className, children, ...props }: AccordionPrimitive.Trigger.Props): JSX.Element;
 
 /**
  * Accessible confirmation dialog with cancel and action buttons.
@@ -67,6 +112,10 @@ import { VariantProps } from 'class-variance-authority';
  * making it composable with `<Tooltip>` at the primitive level.
  * For full structural control, use the exported primitives directly.
  *
+ * `className` styles the popup panel. `classNames` exposes the `backdrop`,
+ * `header`, `title`, `description`, `footer`, `closeButton`, and `actionButton`
+ * slots for fine-grained tweaks without dropping to primitives.
+ *
  * @example
  * ```tsx
  * <AlertDialog
@@ -79,7 +128,7 @@ import { VariantProps } from 'class-variance-authority';
  * />
  * ```
  */
-export declare function AlertDialog({ trigger, title, description, children, onClose, onAction, variant, closeText, actionText, className, ...props }: AlertDialogProps): JSX.Element;
+export declare function AlertDialog({ trigger, title, description, children, onClose, onAction, variant, closeText, actionText, className, classNames, ...props }: AlertDialogProps): JSX.Element;
 
 /** Semi-transparent overlay rendered behind the popup. */
 export declare function AlertDialogBackdrop({ className, ...props }: AlertDialogPrimitive.Backdrop.Props): JSX.Element;
@@ -99,9 +148,16 @@ export declare function AlertDialogHeader({ className, ...props }: HTMLAttribute
 /**
  * Dialog content container. Includes Portal, Backdrop and Viewport internally.
  * Pass `portalProps` to configure the portal (e.g. a custom `container`).
+ * `classNames` styles the internal `backdrop` and `viewport` slots.
  */
-export declare function AlertDialogPopup({ className, portalProps, ...props }: AlertDialogPrimitive.Popup.Props & {
+export declare function AlertDialogPopup({ className, classNames, portalProps, ...props }: AlertDialogPrimitive.Popup.Props & {
     portalProps?: AlertDialogPrimitive.Portal.Props;
+    classNames?: {
+        /** Overlay rendered behind the dialog. */
+        backdrop?: string;
+        /** Full-screen container that centers the popup. */
+        viewport?: string;
+    };
 }): JSX.Element;
 
 export { AlertDialogPrimitive }
@@ -125,8 +181,25 @@ export declare type AlertDialogProps = Omit<AlertDialogPrimitive.Root.Props, "ch
     closeText?: ReactNode;
     /** Label for the action button. @default "Confirm" */
     actionText?: ReactNode;
-    /** Additional className forwarded to the popup panel. */
+    /** Styles the dialog popup panel. */
     className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Overlay rendered behind the dialog. */
+        backdrop?: string;
+        /** Layout wrapper for title and description. */
+        header?: string;
+        /** Dialog heading. */
+        title?: string;
+        /** Supporting text below the title. */
+        description?: string;
+        /** Layout wrapper for action buttons. */
+        footer?: string;
+        /** Cancel button. */
+        closeButton?: string;
+        /** Action button. */
+        actionButton?: string;
+    };
 };
 
 /** Context root. Holds open state and wraps all dialog parts. */
@@ -158,33 +231,127 @@ declare interface AsyncState<T> {
 
 export declare type AtLeastOne<T> = [T, ...T[]];
 
-export declare const AutoComplete: ({ items, placeholder, emptyMessage, onSelect, containerClassName, containerProps, inputClassName, inputProps, listClassName, listProps, itemClassName, itemProps, emptyClassName, emptyProps, }: Props) => JSX.Element;
+export declare function Autocomplete<TOption extends AutocompleteOption = AutocompleteOption>({ items, value, defaultValue, onValueChange, disabled, readOnly, isLoading, filter, autoHighlight, placeholder, emptyMessage, loadingMessage, renderOption, adornment, startAddon, className, classNames, }: AutocompleteProps<TOption>): default_2.ReactElement;
+
+export declare function AutocompleteClear({ className, children, ...props }: AutocompletePrimitive.Clear.Props): default_2.ReactElement;
+
+export declare function AutocompleteCollection({ ...props }: AutocompletePrimitive.Collection.Props): default_2.ReactElement;
+
+export declare function AutocompleteEmpty({ className, ...props }: AutocompletePrimitive.Empty.Props): default_2.ReactElement;
+
+export declare function AutocompleteGroup({ className, ...props }: AutocompletePrimitive.Group.Props): default_2.ReactElement;
+
+export declare function AutocompleteGroupLabel({ className, ...props }: AutocompletePrimitive.GroupLabel.Props): default_2.ReactElement;
 
-export declare const AutoCompleteDialog: ({ children, ...props }: AutoCompleteDialogProps) => JSX.Element;
+export declare function AutocompleteInput({ className, adornment, startAddon, triggerProps, clearProps, ...props }: AutocompletePrimitive.Input.Props & {
+    adornment?: "trigger" | "clear";
+    startAddon?: default_2.ReactNode;
+    ref?: default_2.Ref<HTMLInputElement>;
+    triggerProps?: AutocompletePrimitive.Trigger.Props;
+    clearProps?: AutocompletePrimitive.Clear.Props;
+}): default_2.ReactElement;
+
+export declare function AutocompleteItem({ className, children, ...props }: AutocompletePrimitive.Item.Props): default_2.ReactElement;
 
-declare interface AutoCompleteDialogProps extends DialogProps_2 {
+export declare function AutocompleteList({ className, ...props }: AutocompletePrimitive.List.Props): default_2.ReactElement;
+
+export declare interface AutocompleteOption {
+    value: string;
+    label: string;
 }
 
-export declare const AutoCompleteEmpty: (props: React_2.ComponentProps<typeof Command.Empty>) => JSX.Element;
+export declare function AutocompletePopup({ className, children, side, sideOffset, alignOffset, align, anchor, portalProps, ...props }: AutocompletePrimitive.Popup.Props & {
+    align?: AutocompletePrimitive.Positioner.Props["align"];
+    sideOffset?: AutocompletePrimitive.Positioner.Props["sideOffset"];
+    alignOffset?: AutocompletePrimitive.Positioner.Props["alignOffset"];
+    side?: AutocompletePrimitive.Positioner.Props["side"];
+    anchor?: AutocompletePrimitive.Positioner.Props["anchor"];
+    portalProps?: AutocompletePrimitive.Portal.Props;
+}): default_2.ReactElement;
+
+export { AutocompletePrimitive }
+
+declare interface AutocompleteProps<TOption extends AutocompleteOption = AutocompleteOption> {
+    items: TOption[];
+    value?: TOption | null;
+    defaultValue?: TOption | null;
+    onValueChange?: (value: TOption | null) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    isLoading?: boolean;
+    filter?: AutocompletePrimitive.Root.Props<TOption>["filter"];
+    autoHighlight?: boolean | "always";
+    placeholder?: string;
+    emptyMessage?: string;
+    loadingMessage?: string;
+    renderOption?: (option: TOption) => default_2.ReactNode;
+    adornment?: "trigger" | "clear";
+    startAddon?: default_2.ReactNode;
+    /** Styles the input field. */
+    className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Dropdown popup container. */
+        popup?: string;
+        /** Scrollable list inside the popup. */
+        list?: string;
+        /** Each option item. */
+        item?: string;
+        /** Empty state message. */
+        empty?: string;
+        /** Status row (e.g. loading message). */
+        status?: string;
+    };
+}
 
-export declare const AutoCompleteGroup: ({ className, ...props }: React_2.ComponentProps<typeof Command.Group>) => JSX.Element;
+export declare const AutocompleteRoot: typeof AutocompletePrimitive.Root;
 
-export declare const AutoCompleteInput: ({ className, ...props }: React_2.ComponentProps<typeof Command.Input>) => JSX.Element;
+/**
+ * Groups items into a horizontal row within the list.
+ * Use to create multi-column grid layouts (color swatches, icon grids, emoji pickers).
+ * Each `AutocompleteItem` inside the row remains fully keyboard-navigable.
+ *
+ * ```tsx
+ * <AutocompleteList>
+ *   {(row) => (
+ *     <AutocompleteRow key={row.id}>
+ *       {row.items.map((item) => (
+ *         <AutocompleteItem key={item.value} value={item}>
+ *           {item.label}
+ *         </AutocompleteItem>
+ *       ))}
+ *     </AutocompleteRow>
+ *   )}
+ * </AutocompleteList>
+ * ```
+ */
+export declare function AutocompleteRow({ className, ...props }: AutocompletePrimitive.Row.Props): default_2.ReactElement;
 
-export declare const AutoCompleteItem: ({ className, ...props }: React_2.ComponentProps<typeof Command.Item>) => JSX.Element;
+export declare function AutocompleteSeparator({ className, ...props }: AutocompletePrimitive.Separator.Props): default_2.ReactElement;
 
-export declare const AutoCompleteList: ({ className, ...props }: React_2.ComponentProps<typeof Command.List>) => JSX.Element;
+export declare function AutocompleteStatus({ className, ...props }: AutocompletePrimitive.Status.Props): default_2.ReactElement;
 
-export declare const AutoCompleteRoot: ({ className, ...props }: React_2.ComponentProps<typeof Command>) => JSX.Element;
+export declare function AutocompleteTrigger({ className, children, ...props }: AutocompletePrimitive.Trigger.Props): default_2.ReactElement;
 
-export declare const AutoCompleteSeparator: ({ className, ...props }: React_2.ComponentProps<typeof Command.Separator>) => JSX.Element;
+/**
+ * Renders the selected value's label outside the input element.
+ * Useful when building custom trigger-style layouts where the selected item
+ * must be displayed independently — e.g., inside a badge, a button, or a custom
+ * trigger that replaces the input entirely.
+ * Renders nothing when no item is selected.
+ */
+export declare function AutocompleteValue({ ...props }: AutocompletePrimitive.Value.Props): default_2.ReactElement;
 
-export declare const AutoCompleteShortcut: ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>) => JSX.Element;
+export declare function Avatar({ src, alt, fallback, badge, delay, size, className, classNames, ...props }: AvatarProps): JSX.Element;
 
-export declare function Avatar({ src, alt, fallback, delay, shape, size, className, imageProps, fallbackProps, ...props }: AvatarProps): JSX.Element;
+export declare function AvatarBadge({ className, ...props }: ComponentProps<"span">): JSX.Element;
 
 export declare function AvatarFallback({ className, ...props }: AvatarPrimitive.Fallback.Props): JSX.Element;
 
+export declare function AvatarGroup({ className, ...props }: ComponentProps<"div">): JSX.Element;
+
+export declare function AvatarGroupCount({ className, size, ...props }: ComponentProps<"div"> & VariantProps<typeof avatarVariants>): JSX.Element;
+
 export declare function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props): JSX.Element;
 
 export { AvatarPrimitive }
@@ -193,23 +360,27 @@ declare interface AvatarProps extends Omit<AvatarPrimitive.Root.Props, "children
     src?: string;
     alt: string;
     fallback?: ReactNode;
+    badge?: ReactNode;
     delay?: AvatarPrimitive.Fallback.Props["delay"];
-    shape?: VariantProps<typeof avatarVariants>["shape"];
     size?: VariantProps<typeof avatarVariants>["size"];
-    imageProps?: AvatarPrimitive.Image.Props;
-    fallbackProps?: AvatarPrimitive.Fallback.Props;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Image element rendered when `src` loads successfully. */
+        image?: string;
+        /** Fallback rendered when no image is available. */
+        fallback?: string;
+        /** Status/notification badge rendered over the avatar. */
+        badge?: string;
+    };
 }
 
-export declare function AvatarRoot({ className, shape, size, ...props }: AvatarPrimitive.Root.Props & VariantProps<typeof avatarVariants>): JSX.Element;
+export declare function AvatarRoot({ className, size, ...props }: AvatarPrimitive.Root.Props & VariantProps<typeof avatarVariants>): JSX.Element;
 
 declare const avatarVariants: (props?: ({
-    shape?: "circle" | "square" | null | undefined;
-    size?: "sm" | "lg" | "xs" | "md" | "xl" | null | undefined;
+    size?: "xs" | "sm" | "lg" | "md" | "xl" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const BackgroundImage: ({ src, ...props }: Props_2) => JSX.Element;
-
-export declare const BaseButton: ({ asChild, onClick, loading: prop, showLoader, icon, iconPosition, loaderReplace, style, ...props }: Props_4) => JSX.Element;
+export declare const BaseButton: ({ onClick, loading: prop, style, children, ...props }: Props_2) => JSX.Element;
 
 declare type BaseButtonProps = ComponentProps<typeof BaseButton>;
 
@@ -218,36 +389,60 @@ export declare type BaseEntity = {
     createdAt: Date;
 };
 
-declare type BaseProps = FormPrimitive.Props;
-
-declare type BaseProps_2 = {
-    icon?: React.ReactNode;
-    rounded?: TagVariant["rounded"];
-} & StyleProps & React.HTMLAttributes<HTMLDivElement>;
+export declare const Button: ({ variant, size, className, icon, children, ...rest }: Props) => JSX.Element;
 
-export declare const Button: (props: Props_3) => JSX.Element;
+declare type ButtonOverrides = Omit<ComponentProps<typeof Button>, "onClick" | "disabled" | "render" | "children" | "nativeButton">;
 
 declare type ButtonProps = ComponentProps<typeof Button>;
 
 export declare const buttonVariants: (props?: ({
-    variant?: "default" | "link" | "error" | "success" | "outline" | "secondary" | "ghost" | null | undefined;
-    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
-    shape?: "rounded" | "circle" | "square" | null | undefined;
+    variant?: "default" | "link" | "outline" | "secondary" | "ghost" | "error" | "success" | "warning" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export declare function Calendar({ className, classNames, showOutsideDays, components: userComponents, mode, captionLayout, startMonth, endMonth, ...props }: React_2.ComponentProps<typeof DayPicker>): React_2.ReactElement;
 
-export declare const Card: ({ className, ...props }: default_2.HTMLAttributes<HTMLDivElement>) => JSX.Element;
-
-export declare const CardContent: ({ className, ...props }: default_2.HTMLAttributes<HTMLDivElement>) => JSX.Element;
-
-export declare const CardDescription: ({ className, ...props }: default_2.HTMLAttributes<HTMLParagraphElement>) => JSX.Element;
-
-export declare const CardFooter: ({ className, ...props }: default_2.HTMLAttributes<HTMLDivElement>) => JSX.Element;
+export declare function Card({ title, description, action, footer, children, size, className, classNames, ...props }: CardProps): JSX.Element;
+
+export declare function CardAction({ className, ...props }: default_2.ComponentProps<"div">): JSX.Element;
+
+export declare function CardContent({ className, ...props }: default_2.ComponentProps<"div">): JSX.Element;
+
+export declare function CardDescription({ className, ...props }: default_2.ComponentProps<"div">): JSX.Element;
+
+export declare function CardFooter({ className, ...props }: default_2.ComponentProps<"div">): JSX.Element;
+
+export declare function CardHeader({ className, ...props }: default_2.ComponentProps<"div">): JSX.Element;
+
+declare interface CardProps extends Omit<default_2.ComponentProps<"div">, "children" | "title"> {
+    title?: default_2.ReactNode;
+    description?: default_2.ReactNode;
+    action?: default_2.ReactNode;
+    footer?: default_2.ReactNode;
+    children?: default_2.ReactNode;
+    size?: "default" | "sm";
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Header wrapper holding title, description, and action. */
+        header?: string;
+        /** Card title text. */
+        title?: string;
+        /** Supporting description below the title. */
+        description?: string;
+        /** Action area on the right of the header. */
+        action?: string;
+        /** Body content rendered between the header and the footer. */
+        content?: string;
+        /** Footer area below the content. */
+        footer?: string;
+    };
+}
 
-export declare const CardHeader: ({ className, ...props }: default_2.HTMLAttributes<HTMLDivElement>) => JSX.Element;
+export declare function CardRoot({ className, size, ...props }: default_2.ComponentProps<"div"> & {
+    size?: "default" | "sm";
+}): JSX.Element;
 
-export declare const CardTitle: ({ className, ...props }: default_2.HTMLAttributes<HTMLHeadingElement>) => JSX.Element;
+export declare function CardTitle({ className, ...props }: default_2.ComponentProps<"div">): JSX.Element;
 
 export declare const Center: ({ as: Tag, inline, className, ...props }: CenterProps) => JSX.Element;
 
@@ -262,30 +457,70 @@ export declare const Checkbox: typeof CheckboxSingle & {
     Legend: typeof CheckboxLegend;
 };
 
-export declare function CheckboxGroup({ className, ...props }: CheckboxGroup_3.Props): React_2.ReactElement;
+export declare function CheckboxGroup({ legend, children, items, defaultValue, value, onValueChange, allValues, disabled, controlFirst, className, }: CheckboxGroupProps): JSX.Element;
 
-declare function CheckboxGroup_2({ legend, children, error, description, defaultValue, value, onChange, allValues, disabled, controlFirst, className, }: CheckboxGroupProps): React_2.ReactElement;
+declare function CheckboxGroup_2({ legend, children, error, description, defaultValue, value, onValueChange, allValues, disabled, controlFirst, className, classNames, }: CheckboxGroupProps_2): React_2.ReactElement;
+
+export declare const CheckboxGroupContext: React_2.Context<{
+    controlFirst: boolean;
+    invalid: boolean;
+}>;
 
 export declare interface CheckboxGroupProps {
+    legend?: ReactNode;
+    children?: ReactNode;
+    items?: CheckboxOption[];
+    defaultValue?: string[];
+    value?: string[];
+    onValueChange?: (value: string[]) => void;
+    allValues?: string[];
+    disabled?: boolean;
+    controlFirst?: boolean;
+    className?: string;
+}
+
+declare interface CheckboxGroupProps_2 {
     legend?: ReactNode;
     children: ReactNode;
     error?: string;
     description?: ReactNode;
     defaultValue?: string[];
     value?: string[];
-    onChange?: (value: string[]) => void;
+    onValueChange?: (value: string[]) => void;
     allValues?: string[];
     disabled?: boolean;
     controlFirst?: boolean;
     className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Legend element above the items. */
+        legend?: string;
+        /** Wrapper around the rendered children (items). */
+        items?: string;
+        /** Description shown below the items when there is no error. */
+        description?: string;
+        /** Error message shown below the items. */
+        error?: string;
+    };
 }
 
+export declare function CheckboxGroupRoot({ className, ...props }: CheckboxGroup_3.Props): JSX.Element;
+
 export declare function CheckboxIndicator({ className, ...props }: CheckboxPrimitive.Indicator.Props): React_2.ReactElement;
 
-declare function CheckboxItem({ className, label, id, ...props }: CheckboxItemProps): React_2.ReactElement;
+declare function CheckboxItem({ className, classNames, label, id, ...props }: CheckboxItemProps): React_2.ReactElement;
 
 export declare interface CheckboxItemProps extends Omit<CheckboxPrimitive.Root.Props, "children"> {
     label: ReactNode;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Flex wrapper around checkbox and label. */
+        wrapper?: string;
+        /** Checkmark indicator inside the checkbox. */
+        indicator?: string;
+        /** Label element next to the checkbox. */
+        label?: string;
+    };
 }
 
 declare function CheckboxLegend({ children, className, }: CheckboxLegendProps): React_2.ReactElement;
@@ -295,64 +530,52 @@ export declare interface CheckboxLegendProps {
     className?: string;
 }
 
+export declare interface CheckboxOption {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+
 export { CheckboxPrimitive }
 
 declare interface CheckboxProps extends Omit<CheckboxPrimitive.Root.Props, "children"> {
     children?: ReactNode;
     label?: ReactNode;
     tooltip?: ReactNode;
-    indicatorProps?: CheckboxPrimitive.Indicator.Props;
     controlFirst?: boolean;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Flex wrapper around checkbox and label (only rendered when a label is provided). */
+        wrapper?: string;
+        /** Checkmark indicator inside the checkbox. */
+        indicator?: string;
+        /** Label element next to the checkbox. */
+        label?: string;
+    };
 }
 
 export declare function CheckboxRoot({ className, ...props }: CheckboxPrimitive.Root.Props): React_2.ReactElement;
 
-declare function CheckboxSingle({ className, indicatorProps, label, children, tooltip, controlFirst, required, id, ...props }: CheckboxProps): React_2.ReactElement;
+declare function CheckboxSingle({ className, classNames, label, children, tooltip, controlFirst, required, id, ...props }: CheckboxProps): React_2.ReactElement;
 
 export declare type ClassName = string | undefined;
 
-export declare const click: (element: HTMLElement) => void;
-
 export declare type ClickEvent = React.MouseEvent<HTMLButtonElement, MouseEvent>;
 
-declare type ClosableProps = BaseProps_2 & {
-    closable: true;
-    onClose: () => void;
-};
-
 export declare function cn(...args: ClassValue[]): string;
 
-export { Collection }
-
-declare type ColorProps = {
-    color: string;
-    variant?: "outline" | "borderless";
-};
-
 export declare type ColumnDef<T> = {
-    /**
-     * Header de la columna
-     */
     header: string | (() => ReactNode);
-    /**
-     * Clave que identifica la columna
-     */
     key: keyof T;
-    /**
-     * Elemento que se renderiza en la celda
-     */
     cell?: (row: T, index: number) => ReactNode;
-    /**
-     * Ancho de la columna
-     */
     width?: string | number;
 };
 
 /**
  * Composite combobox for single and multiple selection.
  *
- * Items shaped as `{ label, value }` or plain strings/numbers work with no
- * extra props. For other shapes, provide `getLabel` and/or `getValue`.
+ * Items shaped as `{ id, name }`, `{ label, value }`, or plain strings/numbers
+ * work with no extra props. For other shapes, provide `getLabel` and/or `getId`.
  *
  * In multiple mode, chips are fit dynamically based on the container width —
  * overflowing items show as "+N más". The popup anchors to the chips container automatically.
@@ -365,20 +588,35 @@ export declare type ColumnDef<T> = {
  */
 export declare function Combobox<TItem = unknown>(allProps: ComboboxProps<TItem>): React_2.ReactElement;
 
-declare type ComboboxBaseProps<TItem = unknown> = Omit<ComboboxRootPropsAlias<TItem, boolean>, "items" | "itemToStringLabel" | "itemToStringValue" | "children" | "multiple" | "onChange" | "value" | "defaultValue"> & {
+declare type ComboboxBaseProps<TItem = unknown> = Omit<ComboboxPrimitive.Root.Props<TItem, boolean>, "items" | "itemToStringLabel" | "itemToStringValue" | "children" | "multiple" | "onValueChange" | "value" | "defaultValue"> & {
     items: readonly TItem[];
+    /** Returns the display text for an item. Used for filter matching, ARIA, and the trigger input. Defaults to `item.label`, `item.name`, `item.title`, or the stringified primitive. */
     getLabel?: (item: TItem) => string;
-    getValue?: (item: TItem) => string;
+    /** Returns a stable string identifier for an item. Used as the React key and as the hidden form value when `name` is set. Defaults to `item.id`, `item.value`, or the stringified primitive. */
+    getId?: (item: TItem) => string;
     renderItem?: (item: TItem) => React_2.ReactNode;
     placeholder?: string;
     emptyText?: string;
-    inputProps?: React_2.ComponentProps<typeof ComboboxInput>;
-    chipsProps?: React_2.ComponentProps<typeof ComboboxChips>;
-    chipsInputProps?: React_2.ComponentProps<typeof ComboboxChipsInput>;
-    popupProps?: React_2.ComponentProps<typeof ComboboxPopup>;
-    itemProps?: ComboboxPrimitive.Item.Props;
-    listProps?: Omit<ComboboxPrimitive.List.Props, "children">;
+    /** Icon or element displayed before the input text (single mode) or chips (multiple mode). */
+    startAddon?: React_2.ReactNode;
     showClear?: boolean;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Text input field in single-select mode. */
+        input?: string;
+        /** Chips container in multiple-select mode. */
+        chips?: string;
+        /** Search input inside the popup in multiple-select mode. */
+        chipsInput?: string;
+        /** Popup panel containing the item list. */
+        popup?: string;
+        /** Scrollable item list inside the popup. */
+        list?: string;
+        /** Individual item row. */
+        item?: string;
+        /** Rendered when no items match the search. */
+        empty?: string;
+    };
 };
 
 export declare function ComboboxChip({ children, removeProps, ...props }: ComboboxPrimitive.Chip.Props & {
@@ -438,21 +676,15 @@ export declare type ComboboxProps<TItem = unknown> = (ComboboxBaseProps<TItem> &
     multiple?: false;
     value?: TItem | null;
     defaultValue?: TItem | null;
-    onChange?: (value: TItem | null) => void;
+    onValueChange?: (value: TItem | null) => void;
 }) | (ComboboxBaseProps<TItem> & {
     multiple: true;
     value?: TItem[];
     defaultValue?: TItem[];
-    onChange?: (value: TItem[]) => void;
+    onValueChange?: (value: TItem[]) => void;
 });
 
-export declare function ComboboxRoot<Value, Multiple extends boolean | undefined = false>({ onChange, ...props }: Omit<ComboboxPrimitive.Root.Props<Value, Multiple>, "onValueChange"> & {
-    onChange?: ComboboxPrimitive.Root.Props<Value, Multiple>["onValueChange"];
-}): React_2.ReactElement;
-
-declare type ComboboxRootPropsAlias<V, M extends boolean | undefined = false> = Omit<ComboboxPrimitive.Root.Props<V, M>, "onValueChange"> & {
-    onChange?: ComboboxPrimitive.Root.Props<V, M>["onValueChange"];
-};
+export declare function ComboboxRoot<Value, Multiple extends boolean | undefined = false>({ ...props }: ComboboxPrimitive.Root.Props<Value, Multiple>): React_2.ReactElement;
 
 export declare function ComboboxRow({ className, ...props }: ComboboxPrimitive.Row.Props): React_2.ReactElement;
 
@@ -474,8 +706,6 @@ export declare function ComboboxTrigger({ className, children, ...props }: Combo
 
 export declare function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props): React_2.ReactElement;
 
-declare type ContainerProps = React_2.ComponentProps<"div">;
-
 export declare type Controllable<C, T extends NonNullable<unknown>> = OverrideProps<HTMLProps<C>, ControllableState<T>>;
 
 export declare type ControllableState<T> = {
@@ -513,12 +743,16 @@ export declare type DateInputFooterProps = {
 export declare type DateInputProps = Omit<ComponentProps<"input">, "value" | "onChange" | "defaultValue"> & {
     value?: Date | null;
     defaultValue?: Date | null;
-    onChange?: (value: Date | null) => void;
+    onValueChange?: (value: Date | null) => void;
     disabledDate?: (date: Date) => boolean;
     renderFooter?: (props: DateInputFooterProps) => ReactNode;
 };
 
-export declare const DatePicker: (props: DatePickerProps) => JSX.Element;
+export declare function DatePicker(props: SingleDatePickerProps): ReactElement;
+
+export declare function DatePicker(props: RangeDatePickerProps): ReactElement;
+
+export declare function DatePicker(props: MultipleDatePickerProps): ReactElement;
 
 declare type DatePickerBaseProps = {
     disabled?: boolean;
@@ -526,6 +760,15 @@ declare type DatePickerBaseProps = {
     renderFooter?: (props: DatePickerFooterProps) => ReactNode;
     className?: string;
     required?: boolean;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Popup panel that opens below the trigger. */
+        popup?: string;
+        /** Calendar grid inside the popup. */
+        calendar?: string;
+        /** Footer wrapper rendered below the calendar when `renderFooter` is provided. */
+        footer?: string;
+    };
 };
 
 export declare type DatePickerFooterProps = SingleFooterProps | RangeFooterProps | MultipleFooterProps;
@@ -546,6 +789,10 @@ export declare type DateRange = {
  * making it composable with `<Tooltip>` at the primitive level.
  * For full structural control, use the exported primitives directly.
  *
+ * `className` styles the popup panel. `classNames` exposes the `backdrop`,
+ * `viewport`, `header`, `title`, `description`, `footer`, and `closeButton`
+ * slots for fine-grained tweaks without dropping to primitives.
+ *
  * @example
  * ```tsx
  * <Dialog
@@ -558,7 +805,7 @@ export declare type DateRange = {
  * </Dialog>
  * ```
  */
-export declare function Dialog({ trigger, title, description, children, footer, onClose, hideClose, closeProps, portalProps, className, onOpenChange, ...props }: DialogProps): JSX.Element;
+export declare function Dialog({ trigger, title, description, children, footer, onClose, hideClose, className, classNames, onOpenChange, ...props }: DialogProps): JSX.Element;
 
 /** Semi-transparent overlay rendered behind the popup. */
 export declare function DialogBackdrop({ className, ...props }: DialogPrimitive.Backdrop.Props): JSX.Element;
@@ -578,12 +825,19 @@ export declare function DialogHeader({ className, ...props }: HTMLAttributes<HTM
 /**
  * Dialog content container. Includes Portal, Backdrop and Viewport internally.
  * Pass `portalProps` to configure the portal (e.g. a custom `container`).
- * Pass `closeProps` to customise the close button.
+ * `classNames` styles the internal `backdrop`, `viewport` and `closeButton` slots.
  */
-export declare function DialogPopup({ className, children, hideClose, closeProps, portalProps, ...props }: DialogPrimitive.Popup.Props & {
+export declare function DialogPopup({ className, classNames, children, hideClose, portalProps, ...props }: DialogPrimitive.Popup.Props & {
     hideClose?: boolean;
-    closeProps?: DialogPrimitive.Close.Props;
     portalProps?: DialogPrimitive.Portal.Props;
+    classNames?: {
+        /** Overlay rendered behind the dialog. */
+        backdrop?: string;
+        /** Full-screen container that centers the popup. */
+        viewport?: string;
+        /** Close (×) button rendered inside the popup. */
+        closeButton?: string;
+    };
 }): JSX.Element;
 
 export { DialogPrimitive }
@@ -603,12 +857,25 @@ export declare type DialogProps = Omit<DialogPrimitive.Root.Props, "children"> &
     onClose?: () => void;
     /** Hides the close (×) button inside the popup. */
     hideClose?: boolean;
-    /** Props forwarded to the close button primitive. */
-    closeProps?: DialogPrimitive.Close.Props;
-    /** Props forwarded to the portal. */
-    portalProps?: DialogPrimitive.Portal.Props;
-    /** Additional className forwarded to the popup panel. */
+    /** Styles the dialog popup panel. */
     className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Overlay rendered behind the dialog. */
+        backdrop?: string;
+        /** Full-screen container that centers the popup. */
+        viewport?: string;
+        /** Layout wrapper for title and description. */
+        header?: string;
+        /** Dialog heading. */
+        title?: string;
+        /** Supporting text below the title. */
+        description?: string;
+        /** Layout wrapper for footer content. */
+        footer?: string;
+        /** Close (×) button rendered inside the popup. */
+        closeButton?: string;
+    };
 };
 
 /** Context root. Holds open state and wraps all dialog parts. */
@@ -626,84 +893,117 @@ export declare function DialogTrigger({ className, ...props }: DialogPrimitive.T
 /** Full-screen container that centers the popup. */
 export declare function DialogViewport({ className, ...props }: DialogPrimitive.Viewport.Props): JSX.Element;
 
-export declare const Divider: (props: Props_5) => JSX.Element;
+export declare function Divider({ className, orientation, ...props }: SeparatorPrimitive.Props): default_2.ReactElement;
 
 export declare const DOTS = "...";
 
-export declare const Dropzone: ({ onFileAdd, onFileRemove, onChangeFiles, files, maxFiles, allowedExtensions, maxFileSize, multiple, renderAcceptedFile, renderRejectedFile, showRejected, className, icon: Icon, iconSize, onError, ...props }: DropzoneProps) => JSX.Element;
+export declare function Dropzone({ onFileAdd, onFileRemove, onFilesChange, files, maxFiles, allowedExtensions, maxFileSize, multiple, renderAcceptedFile, renderRejectedFile, showRejected, className, classNames, icon: Icon, iconSize, onError, label, ...props }: DropzoneProps): JSX.Element;
+
+export declare function DropzoneAcceptedFiles(props: DropzoneFilesProps): JSX.Element;
+
+export declare function DropzoneContent({ className, ...props }: ComponentPropsWithoutRef<"div">): JSX.Element;
+
+export declare type DropzoneFilesProps = {
+    renderFile?: (file: File, remove: () => void) => ReactNode;
+};
+
+export declare function DropzoneItem({ file, onRemove, className, renderIcon, ...props }: DropzoneItemProps): JSX.Element;
+
+export declare type DropzoneItemProps = ComponentPropsWithoutRef<"div"> & {
+    file: File;
+    onRemove: () => void;
+    renderIcon?: (file: File) => ReactNode;
+};
 
 export declare type DropzoneProps = {
-    /**
-     * Función que se ejecuta cuando se agregan archivos
-     */
     onFileAdd?: (files: File[]) => void;
-    /**
-     * Función que se ejecuta cuando se elimina un archivo
-     */
     onFileRemove?: (index: number, type: "accepted" | "rejected") => void;
-    /**
-     * Evento que captura cambios en lista de archivos
-     * @default () => {}
-     */
-    onChangeFiles?: (files: File[]) => void;
-    /**
-     * Lista de archivos
-     * @default []
-     */
+    onFilesChange?: (files: File[]) => void;
     files?: File[];
-    /**
-     * Número máximo de archivos permitidos
-     * @default 1
-     */
     maxFiles?: number;
-    /**
-     * Lista de extensiones permitidas (e.j. ["image/jpeg", "image/png"])
-     * @default []
-     */
     allowedExtensions?: FileTypeValue[];
-    /**
-     * Tamaño máximo de archivo en bytes
-     * @default 5MB
-     */
     maxFileSize?: number;
-    /**
-     * Permite seleccionar múltiples archivos
-     */
     multiple?: boolean;
-    /**
-     * Función para renderizar cada archivo aceptado
-     */
-    renderAcceptedFile?: (file: File, removeItem: () => void) => React.ReactNode;
-    /**
-     * Función para renderizar cada archivo rechazado
-     */
-    renderRejectedFile?: (file: File, removeItem: () => void) => React.ReactNode;
-    /**
-     * Mostrar archivos rechazados
-     * @default false
-     */
+    renderAcceptedFile?: (file: File, removeItem: () => void) => ReactNode;
+    renderRejectedFile?: (file: File, removeItem: () => void) => ReactNode;
     showRejected?: boolean;
-    /**
-     * Clase CSS para el contenedor
-     */
     className?: string;
-    /**
-     * Icono personalizado para el dropzone
-     * @default UploadCloud
-     */
     icon?: LucideIcon;
-    /**
-     * Tamaño del icono
-     * @default 40
-     */
     iconSize?: number;
-    /**
-     * Función que se ejecuta cuando se rechazan archivos
-     */
     onError?: (fileErrors: FileError[]) => void;
+    label?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Dashed drop area that contains the icon and label. */
+        trigger?: string;
+        /** Upload icon rendered inside the trigger. */
+        icon?: string;
+        /** Text container below the icon (label + meta lines). */
+        label?: string;
+        /** Wrapper around the accepted/rejected file lists. */
+        content?: string;
+    };
+} & Omit<ComponentPropsWithoutRef<"div">, "onDrop" | "onError">;
+
+export declare function DropzoneRejectedFiles(props: DropzoneFilesProps): JSX.Element;
+
+export declare function DropzoneRoot({ onFileAdd, onFileRemove, onFilesChange, files: controlledFiles, maxFiles, allowedExtensions, maxFileSize, multiple, onError, children, className, ...props }: DropzoneRootProps): JSX.Element;
+
+export declare type DropzoneRootProps = {
+    onFileAdd?: (files: File[]) => void;
+    onFileRemove?: (index: number, type: "accepted" | "rejected") => void;
+    onFilesChange?: (files: File[]) => void;
+    files?: File[];
+    maxFiles?: number;
+    allowedExtensions?: FileTypeValue[];
+    maxFileSize?: number;
+    multiple?: boolean;
+    onError?: (errors: FileError[]) => void;
+    children?: ReactNode;
 } & Omit<ComponentPropsWithoutRef<"div">, "onDrop" | "onError">;
 
-export declare const EmptyState: ({ icon, title, description, className, children, ...props }: Props_6) => JSX.Element;
+export declare function DropzoneTrigger({ render, className, onClick, children, ...props }: DropzoneTriggerProps): JSX.Element;
+
+export declare type DropzoneTriggerProps = useRender.ComponentProps<"div">;
+
+export declare function Empty({ icon, iconVariant, title, description, action, children, classNames, ...props }: EmptyProps): JSX.Element;
+
+export declare function EmptyContent({ className, ...props }: ComponentProps<"div">): JSX.Element;
+
+export declare function EmptyDescription({ className, ...props }: ComponentProps<"div">): JSX.Element;
+
+export declare function EmptyHeader({ className, ...props }: ComponentProps<"div">): JSX.Element;
+
+export declare function EmptyMedia({ className, variant, ...props }: ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>): JSX.Element;
+
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare interface EmptyProps extends Omit<ComponentProps<typeof EmptyRoot>, "title"> {
+    icon?: ReactNode;
+    iconVariant?: VariantProps<typeof emptyMediaVariants>["variant"];
+    title?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Wrapper around media, title and description. */
+        header?: string;
+        /** Box that frames the icon (chip when `iconVariant="icon"`). */
+        media?: string;
+        /** Title text. */
+        title?: string;
+        /** Description text below the title. */
+        description?: string;
+        /** Wrapper around the `action` slot. */
+        content?: string;
+    };
+}
+
+export declare function EmptyRoot({ className, ...props }: ComponentProps<"div">): JSX.Element;
+
+export declare function EmptyTitle({ className, ...props }: ComponentProps<"div">): JSX.Element;
 
 export declare const ensureReactElement: <P>({ children, as: Wrapper, props, }: EnsureReactElementProps<P>) => ReactElement;
 
@@ -717,32 +1017,6 @@ export declare type Entity<T> = {
     [K in keyof T]: T[K];
 } & BaseEntity;
 
-declare interface ExtendedProps {
-    containerClassName: ClassName;
-    inputClassName: ClassName;
-    listClassName: ClassName;
-    itemClassName: ClassName;
-    emptyClassName: ClassName;
-    containerProps: ComponentProps<typeof AutoCompleteRoot>;
-    inputProps: ComponentProps<typeof AutoCompleteInput>;
-    listProps: ComponentProps<typeof AutoCompleteList>;
-    itemProps: ComponentProps<typeof AutoCompleteItem>;
-    emptyProps: ComponentProps<typeof AutoCompleteEmpty>;
-}
-
-declare interface ExtendedProps_2 {
-    theadClassName?: ClassName;
-    theadProps?: HTMLProps<HTMLTableSectionElement>;
-    tbodyClassName?: ClassName;
-    tbodyProps?: HTMLProps<HTMLTableSectionElement>;
-    trClassName?: ClassName;
-    trProps?: HTMLProps<HTMLTableRowElement>;
-    thClassName?: ClassName;
-    thProps?: HTMLProps<HTMLTableCellElement>;
-    tdClassName?: ClassName;
-    tdProps?: Omit<HTMLProps<HTMLTableCellElement>, "onDoubleClick">;
-}
-
 /**
  * Extracts the initials from a string.
  * @param {string} string - The input string.
@@ -750,7 +1024,7 @@ declare interface ExtendedProps_2 {
  */
 export declare const extractInitials: (string: string) => string;
 
-export declare function Field({ label, description, error, required, tooltip, inline, children, className, labelProps, labelClassName, descriptionProps, descriptionClassName, errorProps, errorClassName, invalid, ...rootProps }: FieldProps): JSX.Element;
+export declare function Field({ label, description, error, required, tooltip, inline, children, className, classNames, invalid, ...rootProps }: FieldProps): JSX.Element;
 
 export declare const FieldControl: typeof FieldPrimitive.Control;
 
@@ -771,6 +1045,8 @@ export declare function FieldItem({ className, ...props }: FieldPrimitive.Item.P
 
 export declare function FieldLabel({ className, ...props }: FieldPrimitive.Label.Props): JSX.Element;
 
+export declare function FieldLegend({ className, ...props }: FieldsetPrimitive.Legend.Props): JSX.Element;
+
 export { FieldPrimitive }
 
 export declare interface FieldProps extends Omit<FieldPrimitive.Root.Props, "children"> {
@@ -795,27 +1071,34 @@ export declare interface FieldProps extends Omit<FieldPrimitive.Root.Props, "chi
      */
     inline?: boolean;
     children?: ReactNode;
-    labelProps?: FieldPrimitive.Label.Props;
-    labelClassName?: string;
-    descriptionProps?: FieldPrimitive.Description.Props;
-    descriptionClassName?: string;
-    errorProps?: Omit<FieldPrimitive.Error.Props, "match" | "children">;
-    errorClassName?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Label rendered above (or beside, when `inline`) the control. */
+        label?: string;
+        /** Helper text below the control. */
+        description?: string;
+        /** Error message rendered when the field is invalid. */
+        error?: string;
+    };
 }
 
-export declare function FieldRoot({ className, required, ...props }: FieldPrimitive.Root.Props & {
+export declare function FieldRoot({ className, required, name, ...props }: FieldPrimitive.Root.Props & {
     required?: boolean;
 }): JSX.Element;
 
+export declare function FieldSet({ className, ...props }: FieldsetPrimitive.Root.Props): JSX.Element;
+
+export { FieldsetPrimitive }
+
 export declare const FieldValidity: typeof FieldPrimitive.Validity;
 
-declare type FileError = {
+export declare type FileError = {
     file: File;
     errorMessage: string;
     errorCode: FileErrorCode;
 };
 
-declare type FileErrorCode = "INVALID_EXTENSION" | "FILE_TOO_LARGE" | "MAX_FILES_EXCEEDED";
+export declare type FileErrorCode = "INVALID_EXTENSION" | "FILE_TOO_LARGE" | "MAX_FILES_EXCEEDED";
 
 export declare const FileType: {
     readonly JPEG: "image/jpeg";
@@ -847,22 +1130,11 @@ export declare const FileTypeGroups: Record<string, FileTypeValue[]>;
 
 export declare type FileTypeValue = (typeof FileType)[keyof typeof FileType];
 
-export declare function Form({ onSubmit, onFormSubmit, className, ...props }: FormProps): default_2.ReactElement;
+export declare function Form(props: FormProps): default_2.ReactElement;
 
 export { FormPrimitive }
 
-export declare interface FormProps extends Omit<BaseProps, "onSubmit" | "onFormSubmit"> {
-    onSubmit?: BaseProps["onFormSubmit"];
-    onFormSubmit?: BaseProps["onFormSubmit"];
-}
-
-export declare interface GenericMenuProps {
-    trigger: default_2.ReactNode;
-    items: MenuItemType[];
-    side?: "top" | "right" | "bottom" | "left";
-    offset?: ComponentPropsWithoutRef<typeof MenuContent>["sideOffset"];
-    contentProps?: ComponentPropsWithoutRef<typeof MenuContent>;
-}
+export declare type FormProps = FormPrimitive.Props;
 
 export declare type GenericObject<T = any> = {
     [key: string]: T;
@@ -872,12 +1144,30 @@ declare type GenericObject_2 = Record<string, any>;
 
 export declare const getFormData: (event: FormEvent<HTMLFormElement>) => Record<string, string>;
 
-export declare const Heading: <C extends React.ElementType = "h2">({ className, size, weight, as, ...props }: Props_7<C>) => JSX.Element;
+export declare type GetPageHref = (state: {
+    page: number;
+    pageSize: number;
+}) => string;
+
+export declare function HookField<T extends FieldValues = FieldValues, TName extends FieldPath<T> = FieldPath<T>>({ name, rules, render, ...fieldProps }: HookFieldProps<T, TName>): JSX.Element;
 
-declare const HeadingVariants: (props?: ({
-    size?: "sm" | "lg" | "md" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | null | undefined;
-    weight?: "bold" | "normal" | "medium" | "semibold" | null | undefined;
-} & ClassProp) | undefined) => string;
+declare type HookFieldProps<T extends FieldValues = FieldValues, TName extends FieldPath<T> = FieldPath<T>> = Omit<FieldProps, "children" | "error" | "render" | "name"> & {
+    name: TName;
+    rules?: RegisterOptions<T, TName>;
+    render: (field: HookFieldRenderProps<T, TName>) => ReactNode;
+};
+
+export declare type HookFieldRenderProps<T extends FieldValues = FieldValues, TName extends FieldPath<T> = FieldPath<T>> = ControllerRenderProps<T, TName> & {
+    invalid: boolean;
+};
+
+export declare function HookForm<T extends FieldValues>({ form, onFormSubmit, children, ...props }: HookFormProps<T>): JSX.Element;
+
+declare type HookFormProps<T extends FieldValues> = Omit<ComponentProps<typeof Form>, "onSubmit" | "onFormSubmit" | "children"> & {
+    form: UseFormReturn<T>;
+    onFormSubmit: SubmitHandler<T>;
+    children: ReactNode;
+};
 
 declare type HotkeyEventName = "keydown" | "keypress" | "keyup";
 
@@ -890,35 +1180,33 @@ declare type HotkeyOptions = {
 
 export declare type ID = string | number;
 
-export declare function Input({ className, nativeInput, onChange, ...props }: InputProps): JSX.Element;
+export declare function Input({ className, nativeInput, onValueChange, ...props }: InputProps): JSX.Element;
 
 export declare const inputBaseClasses = "h-10 w-full px-3 py-2 rounded-md border border-input bg-background text-sm outline-none transition-shadow placeholder:text-muted-foreground";
 
 export { InputPrimitive }
 
 export declare type InputProps = Omit<InputPrimitive.Props, "size" | "onChange"> & {
-    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    onValueChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
     nativeInput?: boolean;
 };
 
-declare interface ItemTimeline {
-    content?: ReactNode;
-    icon?: ReactNode;
-    status?: "done" | "pending" | "error";
-    color?: string;
-}
-
 export declare function Kbd({ className, ...props }: React_2.ComponentProps<"kbd">): React_2.ReactElement;
 
 export declare function KbdGroup({ className, ...props }: React_2.ComponentProps<"kbd">): React_2.ReactElement;
 
-declare type Keys = string | string[];
-
-export declare function Label({ className, render, required, tooltip, children, ...props }: LabelProps): default_2.ReactElement;
+export declare function Label({ className, render, required, tooltip, classNames, children, ...props }: LabelProps): default_2.ReactElement;
 
 declare interface LabelProps extends useRender.ComponentProps<"label"> {
     required?: boolean;
     tooltip?: ReactNode;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Red asterisk rendered when `required` is true. */
+        asterisk?: string;
+        /** Info-icon button rendered when `tooltip` is set. */
+        tooltip?: string;
+    };
 }
 
 /**
@@ -948,13 +1236,22 @@ export declare type LibraryProviderProps = {
     tooltipDelay?: ComponentPropsWithoutRef<typeof TooltipPrimitive.Provider>["delay"];
 } & Omit<ToastProviderProps, "children">;
 
-export declare const Loader: ({ center, containerClassName, variant, size, ...props }: Props_8) => JSX.Element;
+export declare type LinkComponent = ElementType<LinkRenderProps> | ComponentType<LinkRenderProps>;
+
+export declare type LinkRenderProps = {
+    href: string;
+    children?: ReactNode;
+    className?: string;
+    onClick?: (event: React.MouseEvent) => void;
+};
+
+export declare const Loader: ({ center, classNames, variant, size, ...props }: Props_3) => JSX.Element;
 
 declare type LoaderVariants = VariantProps<typeof loaderVariants>;
 
 declare const loaderVariants: (props?: ({
-    variant?: "error" | "success" | "secondary" | "ghost" | "primary" | "warning" | "info" | null | undefined;
-    size?: "default" | "sm" | "lg" | "xs" | "xl" | null | undefined;
+    variant?: "secondary" | "ghost" | "error" | "success" | "warning" | "primary" | "info" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "xl" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export declare type Loose<T> = T | (string & {});
@@ -965,99 +1262,111 @@ export declare type MaybeRef<T> = T | MutableRefObject<T>;
 
 declare type MaybeReturn<TState> = Return<TState | undefined, ((state: TState | undefined) => Partial<TState>) | Partial<TState>>;
 
-export declare const Menu: ({ trigger, items, contentProps, side, offset, }: GenericMenuProps) => JSX.Element;
-
-export declare const MenuCheckboxItem: ({ className, children, checked, ...props }: MenuCheckboxItemProps) => JSX.Element;
-
-declare type MenuCheckboxItemProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>;
+export declare const Menu: ({ trigger, items, className, side, align, offset, alignOffset, classNames, }: MenuProps) => JSX.Element;
 
-export declare const MenuContent: ({ className, sideOffset, ...props }: MenuContentProps) => JSX.Element;
-
-declare type MenuContentProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.Content>;
-
-export declare const MenuGroup: (props: React_2.ComponentProps<typeof DropdownMenuPrimitive.Group>) => JSX.Element;
+export declare function MenuCheckboxItem({ className, children, checked, inset, ...props }: Menu_2.CheckboxItem.Props & {
+    inset?: boolean;
+}): JSX.Element;
 
-export declare const MenuItem: ({ className, inset, ...props }: MenuItemProps) => JSX.Element;
+export declare function MenuGroup({ ...props }: Menu_2.Group.Props): JSX.Element;
 
-declare type MenuItemBase<T extends ElementType> = ComponentPropsWithoutRef<T> & {
-    label?: ReactNode;
-    type: string;
-} & Shortcut;
+export declare function MenuItem({ className, inset, variant, ...props }: Menu_2.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "error";
+}): JSX.Element;
 
-declare type MenuItemCheckbox = MenuItemBase<typeof MenuCheckboxItem> & {
+declare type MenuItemCheckbox = {
     type: "checkbox";
+    label: React_2.ReactNode;
+    shortcut?: string;
+} & Omit<React_2.ComponentProps<typeof MenuCheckboxItem>, "children">;
+
+declare type MenuItemGroup = {
+    type: "group";
+    label?: React_2.ReactNode;
+    items: MenuItemType[];
 };
 
-declare type MenuItemItem = MenuItemBase<typeof MenuItem> & {
+declare type MenuItemItem = {
     type: "item";
-};
+    label: React_2.ReactNode;
+    shortcut?: string;
+} & Omit<React_2.ComponentProps<typeof MenuItem>, "children">;
 
-declare type MenuItemLabel = MenuItemBase<typeof MenuLabel> & {
+declare type MenuItemLabel = {
     type: "label";
-};
+    label: React_2.ReactNode;
+} & Omit<React_2.ComponentProps<typeof MenuLabel>, "children">;
 
-declare type MenuItemProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
-    inset?: boolean;
-};
-
-declare type MenuItemRadio = MenuItemBase<typeof MenuRadioItem> & {
+declare type MenuItemRadio = {
     type: "radio";
+    label: React_2.ReactNode;
+    shortcut?: string;
+} & Omit<React_2.ComponentProps<typeof MenuRadioItem>, "children">;
+
+declare type MenuItemRadioGroup = {
+    type: "radio-group";
+    value?: string;
+    onValueChange?: (value: string) => void;
+    items: MenuItemRadio[];
 };
 
-declare type MenuItemSeparator = MenuItemBase<typeof MenuSeparator> & {
+declare type MenuItemSeparator = {
     type: "separator";
-};
+} & React_2.ComponentProps<typeof MenuSeparator>;
 
-declare type MenuItemSubmenu = MenuItemBase<typeof MenuSubTrigger> & {
+declare type MenuItemSubmenu = {
     type: "submenu";
+    label: React_2.ReactNode;
     items: MenuItemType[];
-};
-
-export declare type MenuItemType = MenuItemItem | MenuItemCheckbox | MenuItemRadio | MenuItemLabel | MenuItemSeparator | MenuItemSubmenu;
+} & Omit<React_2.ComponentProps<typeof MenuSubTrigger>, "children">;
 
-export declare const MenuLabel: ({ className, inset, ...props }: MenuLabelProps) => JSX.Element;
+export declare type MenuItemType = MenuItemItem | MenuItemCheckbox | MenuItemRadio | MenuItemRadioGroup | MenuItemLabel | MenuItemSeparator | MenuItemGroup | MenuItemSubmenu;
 
-declare type MenuLabelProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+export declare function MenuLabel({ className, inset, ...props }: Menu_2.GroupLabel.Props & {
     inset?: boolean;
-};
-
-export declare const MenuPortal: (props: React_2.ComponentProps<typeof DropdownMenuPrimitive.Portal>) => JSX.Element;
-
-export declare const MenuRadioGroup: (props: React_2.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>) => JSX.Element;
-
-export declare const MenuRadioItem: ({ className, children, ...props }: MenuRadioItemProps) => JSX.Element;
-
-declare type MenuRadioItemProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>;
+}): JSX.Element;
 
-export declare const MenuRoot: (props: React_2.ComponentProps<typeof DropdownMenuPrimitive.Root>) => JSX.Element;
+export declare function MenuPopup({ align, alignOffset, side, sideOffset, className, ...props }: Menu_2.Popup.Props & Pick<Menu_2.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): JSX.Element;
 
-export declare const MenuSeparator: ({ className, ...props }: MenuSeparatorProps) => JSX.Element;
+export declare function MenuPortal({ ...props }: Menu_2.Portal.Props): JSX.Element;
 
-declare type MenuSeparatorProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.Separator>;
+export declare interface MenuProps {
+    trigger: React_2.ReactElement;
+    items: MenuItemType[];
+    className?: string;
+    side?: React_2.ComponentProps<typeof MenuPopup>["side"];
+    align?: React_2.ComponentProps<typeof MenuPopup>["align"];
+    offset?: React_2.ComponentProps<typeof MenuPopup>["sideOffset"];
+    alignOffset?: React_2.ComponentProps<typeof MenuPopup>["alignOffset"];
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Popup panel that opens below the trigger. */
+        popup?: string;
+    };
+}
 
-export declare const MenuShortcut: ({ className, keys, handler, options, ...props }: MenuShortcutProps_2) => JSX.Element;
+export declare function MenuRadioGroup({ ...props }: Menu_2.RadioGroup.Props): JSX.Element;
 
-declare type MenuShortcutProps = ComponentPropsWithoutRef<typeof MenuShortcut>;
+export declare function MenuRadioItem({ className, children, inset, ...props }: Menu_2.RadioItem.Props & {
+    inset?: boolean;
+}): JSX.Element;
 
-declare type MenuShortcutProps_2 = React_2.ComponentPropsWithoutRef<"span"> & {
-    keys: Keys;
-    handler: (event: KeyboardEvent) => any;
-    options?: HotkeyOptions;
-};
+export declare function MenuRoot({ ...props }: Menu_2.Root.Props): JSX.Element;
 
-export declare const MenuSub: (props: React_2.ComponentProps<typeof DropdownMenuPrimitive.Sub>) => JSX.Element;
+export declare function MenuSeparator({ className, ...props }: Menu_2.Separator.Props): JSX.Element;
 
-export declare const MenuSubContent: ({ className, ...props }: MenuSubContentProps) => JSX.Element;
+export declare function MenuShortcut({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;
 
-declare type MenuSubContentProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.SubContent>;
+export declare function MenuSub({ ...props }: Menu_2.SubmenuRoot.Props): JSX.Element;
 
-export declare const MenuSubTrigger: ({ className, inset, children, ...props }: MenuSubTriggerProps) => JSX.Element;
+export declare function MenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React_2.ComponentProps<typeof MenuPopup>): JSX.Element;
 
-declare type MenuSubTriggerProps = React_2.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+export declare function MenuSubTrigger({ className, inset, children, ...props }: Menu_2.SubmenuTrigger.Props & {
     inset?: boolean;
-};
+}): JSX.Element;
 
-export declare const MenuTrigger: (props: React_2.ComponentProps<typeof DropdownMenuPrimitive.Trigger>) => JSX.Element;
+export declare function MenuTrigger({ ...props }: Menu_2.Trigger.Props): JSX.Element;
 
 export declare function mergeRefs<T = any>(refs: Array<React_2.MutableRefObject<T> | React_2.LegacyRef<T> | undefined | null>): React_2.RefCallback<T>;
 
@@ -1065,7 +1374,7 @@ export declare type MultipleDatePickerProps = DatePickerBaseProps & {
     mode: "multiple";
     value?: Date[];
     defaultValue?: Date[];
-    onChange?: (value: Date[]) => void;
+    onValueChange?: (value: Date[]) => void;
     placeholder?: string;
 };
 
@@ -1076,64 +1385,15 @@ declare type MultipleFooterProps = {
     setValue: (value: Date[]) => void;
 };
 
-export declare const MultiSelect: <TItem extends Record<string, any> = Option_2>({ items, value, valueKey, labelKey, onChange, variant, defaultValue, placeholder, maxCount, className, renderOption, withCheckbox, showSearch, showSelectAll, rootProps, ...props }: MultiSelectProps<TItem>) => JSX.Element;
-
-declare type MultiSelectProps<TItem extends Record<string, any>> = OverrideProps<React_2.ButtonHTMLAttributes<HTMLButtonElement> & OpenProps & VariantProps<typeof multiSelectVariants>, {
-    items: TItem[];
-    /**
-     * Identificador del valor del elemento
-     * @default "value"
-     */
-    valueKey?: keyof TItem;
-    /**
-     * Identificador del label del elemento
-     * @default "label"
-     */
-    value?: string[];
-    onChange?: (value: string[]) => void;
-    defaultValue?: string[];
-    labelKey?: keyof TItem;
-    placeholder?: string;
-    /**
-     * Cantidad máxima de elementos que se van a visualizar
-     * @default 3
-     */
-    maxCount?: number;
-    className?: string;
-    renderOption?: (item: TItem) => React_2.ReactNode;
-    withCheckbox?: boolean;
-    /**
-     * Para mostrar o no la barra de búsqueda
-     * @default true
-     */
-    showSearch?: boolean;
-    /**
-     * Para mostrar o no el "Seleccionar todos"
-     * @default true
-     */
-    showSelectAll?: boolean;
-    /**
-     * Props del PopoverRoot
-     */
-    rootProps?: React_2.ComponentPropsWithoutRef<typeof PopoverRoot>;
-}>;
-
-declare const multiSelectVariants: (props?: ({
-    variant?: "default" | "error" | "secondary" | "primary" | null | undefined;
-} & ClassProp) | undefined) => string;
-
 declare type Mutation<TArgs extends any[], TReturn> = (...args: TArgs) => Promise<TReturn>;
 
-declare type NonClosableProps = BaseProps_2 & {
-    closable?: false;
-    onClose?: never;
-};
-
 declare type noop = (this: any, ...args: any[]) => any;
 
+export declare function normalizeError(error: FieldErrorProp | undefined): FieldErrorItem[];
+
 export declare type Nullable<T> = T | null;
 
-export declare function NumberInput({ className, hideControls, onChange, onValueChange, invalid, placeholder, groupProps, inputProps, decrementProps, incrementProps, ...props }: NumberInputProps): JSX.Element;
+export declare function NumberInput({ className, hideControls, onValueChange, invalid, placeholder, classNames, ...props }: NumberInputProps): JSX.Element;
 
 export declare function NumberInputCursorIcon(props: ComponentProps<"svg">): JSX.Element;
 
@@ -1150,16 +1410,21 @@ export { NumberInputPrimitive }
 export declare interface NumberInputProps extends NumberInputPrimitive.Root.Props {
     /** Hides the increment/decrement buttons. */
     hideControls?: boolean;
-    /** Shorthand for `onValueChange` — receives only the value, without event details. */
-    onChange?: (value: number | null) => void;
     /** Marks the field as invalid, adding the error border to the group. */
     invalid?: boolean;
     /** Forwarded to the underlying input element. */
     placeholder?: string;
-    groupProps?: NumberInputPrimitive.Group.Props;
-    inputProps?: NumberInputPrimitive.Input.Props;
-    decrementProps?: NumberInputPrimitive.Decrement.Props;
-    incrementProps?: NumberInputPrimitive.Increment.Props;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Native `<input>` element. */
+        input?: string;
+        /** Column wrapper around the increment/decrement buttons. */
+        controls?: string;
+        /** Increment button (Chevron up). */
+        increment?: string;
+        /** Decrement button (Chevron down). */
+        decrement?: string;
+    };
 }
 
 export declare function NumberInputRoot({ className, ...props }: NumberInputPrimitive.Root.Props): JSX.Element;
@@ -1168,12 +1433,6 @@ export declare function NumberInputScrubArea({ className, ...props }: NumberInpu
 
 export declare function NumberInputScrubAreaCursor({ className, ...props }: NumberInputPrimitive.ScrubAreaCursor.Props): JSX.Element;
 
-declare type OpenProps = {
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    defaultOpen?: boolean;
-};
-
 declare interface Option_2<TValue = string> {
     label: string;
     value: TValue;
@@ -1183,15 +1442,164 @@ export { Option_2 as Option }
 
 export declare type OverrideProps<T, TOverridden> = Omit<T, keyof TOverridden> & TOverridden;
 
-export declare type PageSize = (typeof TABLE_PAGE_SIZES)[number];
+export declare type PageSize = (typeof PAGINATION_SIZES)[number] | number;
+
+export declare function Pagination({ sizes, selectClassName, rangeClassName, previousClassName, nextClassName, className, ...rootProps }: PaginationProps): JSX.Element;
+
+export declare const PAGINATION_SIZES: readonly [10, 25, 50];
+
+export declare interface PaginationContextValue {
+    currentPage: number;
+    maxPage: number;
+    pageSize: PageSize;
+    totalItems: number;
+    paginationRange: (string | number)[];
+    range: {
+        start: number;
+        end: number;
+    };
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    goTo: (page: number) => void;
+    next: () => void;
+    prev: () => void;
+    setPageSize: (size: PageSize) => void;
+    getPageHref?: GetPageHref;
+    linkComponent: LinkComponent;
+    texts: PaginationTexts;
+}
+
+export declare function PaginationEllipsis({ className, ...props }: ComponentProps<"span">): JSX.Element;
 
-export declare const Pagination: ({ optionProps, className, containerProps, ...rangeProps }: Props_9) => JSX.Element;
+export declare function PaginationFirst({ className, buttonProps, children, }: PaginationNavProps): JSX.Element;
 
-declare interface PaginationOptionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+export declare function PaginationLast({ className, buttonProps, children, }: PaginationNavProps): JSX.Element;
+
+export declare function PaginationLink({ page, isActive: isActiveProp, className, children, buttonProps, }: PaginationLinkProps): JSX.Element;
+
+declare interface PaginationLinkProps {
+    page: number;
     isActive?: boolean;
+    className?: string;
+    children?: ReactNode;
+    buttonProps?: ButtonOverrides;
+}
+
+declare interface PaginationNavProps {
+    className?: string;
+    buttonProps?: ButtonOverrides;
+    children?: ReactNode;
+}
+
+export declare function PaginationNext({ className, buttonProps, children, }: PaginationNavProps): JSX.Element;
+
+export declare function PaginationPageInfo({ children, className, ...props }: PaginationPageInfoProps): JSX.Element;
+
+declare interface PaginationPageInfoProps {
+    className?: string;
+    /**
+     * Custom content. Receives `{ page, max }`, or pass a static ReactNode.
+     * @default `Página ${page} de ${max}`
+     */
+    children?: ReactNode | ((state: {
+        page: number;
+        max: number;
+    }) => ReactNode);
+}
+
+export declare function PaginationPages({ className, linkClassName, ellipsisClassName, }: PaginationPagesProps): JSX.Element;
+
+declare interface PaginationPagesProps {
+    className?: string;
+    linkClassName?: string;
+    ellipsisClassName?: string;
+}
+
+export declare function PaginationPrevious({ className, buttonProps, children, }: PaginationNavProps): JSX.Element;
+
+export declare interface PaginationProps extends Omit<PaginationRootProps, "children"> {
+    sizes?: readonly PageSize[] | PageSize[] | false;
+    selectClassName?: string;
+    rangeClassName?: string;
+    previousClassName?: string;
+    nextClassName?: string;
+}
+
+export declare function PaginationRange({ children, className, ...props }: PaginationRangeProps): JSX.Element;
+
+declare interface PaginationRangeProps {
+    className?: string;
+    /**
+     * Custom content. Receives `{ start, end, total }`, or pass a static ReactNode.
+     * @default `${start} - ${end} de ${total}`
+     */
+    children?: ReactNode | ((state: {
+        start: number;
+        end: number;
+        total: number;
+    }) => ReactNode);
+}
+
+export declare function PaginationRoot({ totalItems, pageSize: pageSizeProp, defaultPageSize, onPageSizeChange, currentPage, defaultCurrentPage, onCurrentPageChange, siblingCount, getPageHref, linkComponent, texts: textsProp, className, children, ...props }: PaginationRootProps): JSX.Element;
+
+export declare interface PaginationRootProps extends Omit<ComponentProps<"nav">, "onChange"> {
+    totalItems: number;
+    pageSize?: PageSize;
+    defaultPageSize?: PageSize;
+    onPageSizeChange?: (size: PageSize) => void;
+    currentPage?: number;
+    defaultCurrentPage?: number;
+    onCurrentPageChange?: (page: number) => void;
+    siblingCount?: number;
+    getPageHref?: GetPageHref;
+    linkComponent?: LinkComponent;
+    texts?: Partial<PaginationTexts>;
+}
+
+export declare function PaginationSizeSelect({ sizes, className, ...props }: PaginationSizeSelectProps): JSX.Element;
+
+declare interface PaginationSizeSelectProps extends Omit<ComponentProps<"select">, "value" | "onChange"> {
+    sizes?: readonly PageSize[] | PageSize[];
+}
+
+export declare interface PaginationTexts {
+    goToFirst: string;
+    goToPrevious: string;
+    goToNext: string;
+    goToLast: string;
+    goToPage: (page: number) => string;
+    total: (n: number) => string;
+    pageInfo: (page: number, max: number) => string;
+    range: (start: number, end: number, total: number) => string;
+    morePages: string;
+}
+
+export declare function PaginationTotal({ children, className, ...props }: PaginationTotalProps): JSX.Element;
+
+declare interface PaginationTotalProps {
+    className?: string;
+    /**
+     * Custom content. Receives the total number of items, or pass a static ReactNode.
+     * @default `${total} resultados`
+     */
+    children?: ReactNode | ((total: number) => ReactNode);
 }
 
-declare function Password({ className, showIcon, hideIcon, onShow, onHide, toggleable, onChange, ...rest }: PasswordProps): JSX.Element;
+declare type ParentIcon = ReactNode | ((isExpanded: boolean) => ReactNode);
+
+/**
+ * Validates `formValues` from `Form.onFormSubmit` against a Zod schema and
+ * returns `{ data, errors }` ready to wire back into `Form`'s `errors` prop.
+ *
+ * - `data` is the typed, parsed value, or `null` when validation fails.
+ * - `errors` is the flattened `fieldErrors` object (empty on success).
+ */
+export declare function parseFormValues<T extends z.ZodType>(schema: T, values: Record<string, unknown>): {
+    data: z.infer<T> | null;
+    errors: Record<string, string[]>;
+};
+
+declare function Password({ className, showIcon, hideIcon, onShow, onHide, toggleable, onValueChange, classNames, ...rest }: PasswordProps): JSX.Element;
 export { Password }
 export { Password as PasswordRoot }
 
@@ -1201,11 +1609,18 @@ declare type PasswordProps = Omit<InputProps, "unstyled" | "nativeInput"> & {
     onShow?: () => void;
     onHide?: () => void;
     toggleable?: boolean;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Native `<input>` element (transparent inside the wrapper). */
+        input?: string;
+        /** Show/hide toggle button on the right. */
+        toggle?: string;
+    };
 };
 export { PasswordProps }
 export { PasswordProps as PasswordRootProps }
 
-export declare function Popover({ trigger, children, title, description, side, align, sideOffset, alignOffset, tooltipStyle, matchTriggerWidth, anchor, popupClassName, triggerProps, popupProps, ...rootProps }: PopoverProps): default_2.ReactElement;
+export declare function Popover({ trigger, children, title, description, side, align, sideOffset, alignOffset, tooltipStyle, matchTriggerWidth, anchor, className, classNames, ...rootProps }: PopoverProps): default_2.ReactElement;
 
 export declare function PopoverClose({ ...props }: PopoverPrimitive.Close.Props): default_2.ReactElement;
 
@@ -1213,8 +1628,9 @@ export declare const PopoverCreateHandle: typeof PopoverPrimitive.createHandle;
 
 export declare function PopoverDescription({ className, ...props }: PopoverPrimitive.Description.Props): default_2.ReactElement;
 
-declare function PopoverPopup({ children, className, side, align, sideOffset, alignOffset, tooltipStyle, matchTriggerWidth, anchor, portalProps, ...props }: PopoverPrimitive.Popup.Props & {
+declare function PopoverPopup({ children, className, side, align, sideOffset, alignOffset, tooltipStyle, matchTriggerWidth, anchor, portalProps, viewportClassName, ...props }: PopoverPrimitive.Popup.Props & {
     portalProps?: PopoverPrimitive.Portal.Props;
+    viewportClassName?: string;
     side?: PopoverPrimitive.Positioner.Props["side"];
     align?: PopoverPrimitive.Positioner.Props["align"];
     sideOffset?: PopoverPrimitive.Positioner.Props["sideOffset"];
@@ -1226,8 +1642,6 @@ declare function PopoverPopup({ children, className, side, align, sideOffset, al
 export { PopoverPopup as PopoverContent }
 export { PopoverPopup }
 
-declare type PopoverPopupOverrideProps = Omit<default_2.ComponentPropsWithoutRef<typeof PopoverPopup>, "children" | "side" | "align" | "sideOffset" | "alignOffset" | "tooltipStyle" | "matchTriggerWidth" | "anchor">;
-
 export { PopoverPrimitive }
 
 declare interface PopoverProps extends Omit<PopoverPrimitive.Root.Props, "children"> {
@@ -1242,9 +1656,13 @@ declare interface PopoverProps extends Omit<PopoverPrimitive.Root.Props, "childr
     tooltipStyle?: boolean;
     matchTriggerWidth?: boolean;
     anchor?: PopoverPrimitive.Positioner.Props["anchor"];
-    popupClassName?: string;
-    triggerProps?: Omit<PopoverPrimitive.Trigger.Props, "render" | "children">;
-    popupProps?: PopoverPopupOverrideProps;
+    /** Styles the popup (visual root). */
+    className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Inner viewport that holds the popup content (padding, overflow). */
+        viewport?: string;
+    };
 }
 
 export declare const PopoverRoot: typeof PopoverPrimitive.Root;
@@ -1282,83 +1700,27 @@ declare const progressTrackVariants: (props?: ({
 
 export declare function ProgressValue({ className, ...props }: Progress_2.Value.Props): React_2.ReactElement;
 
-declare interface Props extends ExtendedProps {
-    items: AutoCompleteItem[];
-    placeholder?: string;
-    emptyMessage?: string;
-    onSelect?: (value: AutoCompleteItem["value"], item: AutoCompleteItem) => any;
-}
-
-declare interface Props_10 extends ComponentPropsWithoutRef<typeof Slot> {
-    /** Si el componente está presente o no */
-    when: ComponentProps<typeof Presence>["present"];
-}
-
-declare type Props_11<T> = {
-    data: T[];
-    columns: ColumnDef<T>[];
-    onRowClick?: (row: T) => void;
-    onDoubleClick?: (row: T) => void;
-    selected?: (row: T) => boolean;
-} & ExtendedProps_2 & Omit<ComponentPropsWithoutRef<typeof TableRoot>, "data" | "selected" | "onDoubleClick">;
-
-declare type Props_12 = {
-    setPageSize?: (value: PageSize) => void;
-    pageSize?: PageSize;
-} & Omit<usePaginationProps, "pageSize"> & TablePaginationExtendedProps;
-
-declare type Props_13 = ClosableProps | NonClosableProps;
-
-declare type Props_14<T extends TreeNode> = TreeRootProps & {
-    items: T[];
+declare type Props = BaseButtonProps & VariantProps<typeof buttonVariants> & {
+    icon?: ReactElement;
 };
 
-declare interface Props_15<T> extends UseAsyncOptions<T> {
-    fn: () => Promise<T>;
-    dependencies?: DependencyList;
-}
-
-declare interface Props_2 extends HTMLProps<HTMLDivElement> {
-    /**
-     * La URL de la imagen
-     */
-    src: string;
-}
-
-declare type Props_3 = BaseButtonProps & VariantProps<typeof buttonVariants>;
-
-declare interface Props_4 extends ComponentProps<"button"> {
-    asChild?: boolean;
+declare interface Props_2 extends ComponentProps<typeof Button_2> {
     loading?: boolean;
-    showLoader?: boolean;
-    icon?: ReactNode;
-    iconPosition?: "start" | "end";
-    loaderReplace?: true;
 }
 
-declare type Props_5 = {
-    orientation?: "horizontal" | "vertical";
-} & HTMLProps<HTMLHRElement>;
-
-declare type Props_6 = ComponentPropsWithoutRef<"div"> & {
-    icon?: ReactNode;
-    title?: ReactNode;
-    description?: ReactNode;
-};
-
-declare type Props_7<C extends React.ElementType> = VariantProps<typeof HeadingVariants> & {
-    as?: C;
-} & Omit<React.ComponentPropsWithoutRef<C>, "as">;
-
-declare type Props_8 = LucideProps & LoaderVariants & {
+declare type Props_3 = LucideProps & LoaderVariants & {
+    /** Renders the loader fixed at the viewport center via `fixed inset-0`. */
     center?: boolean;
-    containerClassName?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Wrapper around the spinner (used for `center` overlay). */
+        container?: string;
+    };
 };
 
-declare interface Props_9 extends useRangePaginationProps {
-    optionProps?: PaginationOptionProps;
-    className?: string;
-    containerProps?: HTMLProps<HTMLDivElement>;
+declare interface Props_4<T> extends UseAsyncOptions<T> {
+    fn: () => Promise<T>;
+    dependencies?: DependencyList;
 }
 
 declare type PropsWithoutValue<T> = Omit<T, "value" | "onChange" | "defaultValue">;
@@ -1369,7 +1731,7 @@ export declare type RangeDatePickerProps = DatePickerBaseProps & {
     mode: "range";
     value?: DateRange;
     defaultValue?: DateRange;
-    onChange?: (value: DateRange) => void;
+    onValueChange?: (value: DateRange) => void;
     placeholder?: string;
 };
 
@@ -1465,30 +1827,37 @@ export { ScrollAreaPrimitive }
 export declare function ScrollBar({ className, orientation, ...props }: ScrollAreaPrimitive.Scrollbar.Props): default_2.ReactElement;
 
 /**
- * Composite select for single and multiple selection. Items shaped as
- * `{ label, value }` or plain strings/numbers work with no extra props.
- * For other shapes, provide `getLabel` and/or `getValue`.
+ * Composite select for single and multiple selection.
+ *
+ * Items shaped as `{ id, name }`, `{ label, value }`, or plain strings/numbers
+ * work with no extra props. For other shapes, provide `getLabel` and/or `getId`.
  *
  * `renderItem` customizes the content **inside** each `SelectItem` (the
  * checkmark indicator is always rendered by the item wrapper).
  *
  * Use `SelectRoot` + primitives directly when you need full structural
- * control beyond what escape-hatch props offer.
+ * control beyond what `className` + `classNames` slots offer.
  */
 export declare function Select<TItem = unknown>(allProps: SelectProps<TItem>): React_2.ReactElement;
 
-declare type SelectBaseProps<TItem = unknown> = Omit<SelectRootPropsAlias<string>, "children" | "onChange" | "value" | "defaultValue" | "items" | "multiple"> & {
+declare type SelectBaseProps<TItem = unknown> = Omit<SelectPrimitive.Root.Props<string, false>, "children" | "onValueChange" | "value" | "defaultValue" | "items" | "multiple"> & {
     items: readonly TItem[];
+    /** Returns the display text for an item. Used for the trigger value and ARIA. Defaults to `item.label`, `item.name`, `item.title`, or the stringified primitive. */
     getLabel?: (item: TItem) => string;
-    getValue?: (item: TItem) => string;
+    /** Returns a stable string identifier for an item. Used as the React key and the underlying option value. Defaults to `item.id`, `item.value`, or the stringified primitive. */
+    getId?: (item: TItem) => string;
+    /** Returns whether an item should be disabled. Defaults to `item.disabled === true`. */
+    getDisabled?: (item: TItem) => boolean;
     renderItem?: (item: TItem) => React_2.ReactNode;
     placeholder?: string;
-    triggerProps?: React_2.ComponentProps<typeof SelectTrigger>;
-    popupProps?: React_2.ComponentProps<typeof SelectPopup>;
-    popupClassName?: string;
-    itemProps?: SelectPrimitive.Item.Props;
-    itemClassName?: string;
     className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Popup panel containing the item list. */
+        popup?: string;
+        /** Individual item row. */
+        item?: string;
+    };
 };
 
 export declare function SelectButton({ className, render, children, ...props }: SelectButtonProps): React_2.ReactElement;
@@ -1523,21 +1892,15 @@ export declare type SelectProps<TItem = unknown> = (SelectBaseProps<TItem> & {
     multiple?: false;
     value?: TItem | null;
     defaultValue?: TItem | null;
-    onChange?: (value: TItem | null) => void;
+    onValueChange?: (value: TItem | null) => void;
 }) | (SelectBaseProps<TItem> & {
     multiple: true;
     value?: TItem[];
     defaultValue?: TItem[];
-    onChange?: (value: TItem[]) => void;
+    onValueChange?: (value: TItem[]) => void;
 });
 
-export declare function SelectRoot<Value = string, Multiple extends boolean | undefined = false>({ onChange, ...props }: Omit<SelectPrimitive.Root.Props<Value, Multiple>, "onValueChange"> & {
-    onChange?: SelectPrimitive.Root.Props<Value, Multiple>["onValueChange"];
-}): React_2.ReactElement;
-
-declare type SelectRootPropsAlias<V = string> = Omit<SelectPrimitive.Root.Props<V, false>, "onValueChange"> & {
-    onChange?: SelectPrimitive.Root.Props<V, false>["onValueChange"];
-};
+export declare function SelectRoot<Value = string, Multiple extends boolean | undefined = false>({ ...props }: SelectPrimitive.Root.Props<Value, Multiple>): React_2.ReactElement;
 
 export declare function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): React_2.ReactElement;
 
@@ -1549,21 +1912,15 @@ export declare const selectTriggerIconClassName = "-me-1 size-4.5 opacity-80 sm:
 
 export declare function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): React_2.ReactElement;
 
-export declare type SetState<T> = Dispatch<SetStateAction<T>>;
-
-declare type Shortcut = Partial<{
-    shortcut: MenuShortcutProps["keys"];
-    onShortcut: MenuShortcutProps["handler"];
-    shortcutOptions: MenuShortcutProps["options"];
-}>;
+export { SeparatorPrimitive }
 
-export declare const Show: ({ when, ...props }: Props_10) => JSX.Element;
+export declare type SetState<T> = Dispatch<SetStateAction<T>>;
 
 export declare type SingleDatePickerProps = DatePickerBaseProps & {
     mode: "single";
     value?: Date | null;
     defaultValue?: Date | null;
-    onChange?: (value: Date | null) => void;
+    onValueChange?: (value: Date | null) => void;
     placeholder?: string;
 };
 
@@ -1587,193 +1944,216 @@ declare interface StackProps extends ComponentProps<"div"> {
     justify?: CSSProperties["justifyContent"];
     align?: CSSProperties["alignItems"];
     gap?: CSSProperties["gap"];
-    wrap?: CSSProperties["flexWrap"];
+    wrap?: CSSProperties["flexWrap"] | boolean;
     grow?: boolean;
 }
 
 export declare type State<T> = [T, SetState<T>];
 
-export declare function Stepper({ items, current, onChange, className, classNameList, classNameItem, classNameButton, classNameIndicator, classNameContent, }: StepperProps): JSX.Element;
+export declare type StepIndicators = Partial<Record<StepState, ReactNode>>;
 
-export declare function StepperContainer({ current: prop, onChange, className, ...props }: StepperContainerProps): JSX.Element;
-
-declare interface StepperContainerProps extends Omit<HTMLProps<HTMLDivElement>, "onChange"> {
-    current?: number;
-    onChange?: (index: number) => void;
-    className?: ClassName;
+declare interface StepItemContextValue {
+    step: number;
+    state: StepState;
+    isDisabled: boolean;
+    isLoading: boolean;
 }
 
-export declare function StepperContent({ value, className, ...props }: StepperContentProps): JSX.Element | null;
+export declare function Stepper({ items, classNames, ...props }: StepperProps): JSX.Element;
+
+export declare function StepperContent({ value, forceMount, className, render, children, ...props }: StepperContentProps): ReactElement<unknown, string | JSXElementConstructor<any>> | null;
 
-declare interface StepperContentProps extends HTMLProps<HTMLDivElement> {
+export declare interface StepperContentProps extends useRender.ComponentProps<"div"> {
     value: number;
+    forceMount?: boolean;
 }
 
-declare interface StepperItemProps {
+declare interface StepperContextValue {
+    activeStep: number;
+    setActiveStep: (step: number) => void;
+    orientation: StepperOrientation;
+    indicators: StepIndicators;
+    triggerMode: StepperTriggerMode;
+}
+
+export declare function StepperDescription({ className, render, children, ...props }: useRender.ComponentProps<"p">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare function StepperIndicator({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare function StepperItem({ step, disabled, loading, className, render, children, ...props }: StepperItemProps): JSX.Element;
+
+export declare interface StepperItemData {
+    title?: ReactNode;
+    description?: ReactNode;
     indicator?: ReactNode;
-    title: ReactNode;
     content?: ReactNode;
     disabled?: boolean;
+    loading?: boolean;
 }
 
-export declare function StepperList({ children, className, ...props }: StepperListProps): JSX.Element;
-
-declare interface StepperListProps extends HTMLProps<HTMLUListElement> {
+export declare interface StepperItemProps extends useRender.ComponentProps<"div"> {
+    step: number;
+    disabled?: boolean;
+    loading?: boolean;
 }
 
-declare interface StepperProps extends Omit<HTMLProps<HTMLDivElement>, "onChange"> {
-    items?: StepperItemProps[];
-    current?: number;
-    onChange?: (index: number) => void;
-    className?: ClassName;
-    classNameList?: ClassName;
-    classNameItem?: ClassName;
-    classNameButton?: ClassName;
-    classNameIndicator?: ClassName;
-    classNameContent?: ClassName;
+export declare function StepperNav({ className, render, children, ...props }: useRender.ComponentProps<"nav">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare type StepperOrientation = "horizontal" | "vertical";
+
+export declare function StepperPanel({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare interface StepperProps extends Omit<StepperRootProps, "children"> {
+    items: StepperItemData[];
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Navigation list that holds every step. */
+        nav?: string;
+        /** Single step container (indicator + label + separator). */
+        item?: string;
+        /** Clickable step button. */
+        trigger?: string;
+        /** Round indicator (number, icon, or check). */
+        indicator?: string;
+        /** Step title above the description. */
+        title?: string;
+        /** Step description below the title. */
+        description?: string;
+        /** Line between steps. */
+        separator?: string;
+        /** Panel below the nav that holds the active step's content. */
+        panel?: string;
+        /** Single step content rendered when the step is active. */
+        content?: string;
+    };
 }
 
-export declare function StepperTrigger({ disabled, value, title, indicator, classNameItem, classNameButton, classNameIndicator, }: StepperTriggerProps): JSX.Element;
+export declare function StepperRoot({ defaultValue, value, onValueChange, orientation, indicators, triggerMode, className, render, children, ...props }: StepperRootProps): JSX.Element;
 
-declare interface StepperTriggerProps {
-    indicator?: ReactNode;
-    title: ReactNode;
-    value: number;
-    disabled?: boolean;
-    classNameItem?: ClassNameValue;
-    classNameButton?: ClassNameValue;
-    classNameIndicator?: ClassNameValue;
+export declare interface StepperRootProps extends useRender.ComponentProps<"div"> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: StepperOrientation;
+    indicators?: StepIndicators;
+    triggerMode?: StepperTriggerMode;
 }
 
-declare type StyleProps = ColorProps | VariantProps_2;
+export declare function StepperSeparator({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare function StepperTitle({ className, render, children, ...props }: useRender.ComponentProps<"h3">): ReactElement<unknown, string | JSXElementConstructor<any>>;
 
-export declare function Switch({ children, label, className, id, thumbProps, controlFirst, tooltip, ...props }: SwitchProps): React_2.ReactElement;
+export declare function StepperTrigger({ className, render, children, ...props }: useRender.ComponentProps<"button">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare type StepperTriggerMode = "both" | "forward-only" | "backward-only" | "none";
+
+export declare type StepState = "active" | "completed" | "inactive" | "loading";
+
+export declare function Switch({ children, label, className, id, controlFirst, tooltip, classNames, ...props }: SwitchProps): React_2.ReactElement;
 
 declare interface SwitchProps extends Omit<Switch_2.Root.Props, "children"> {
     children?: React_2.ReactNode;
     label?: React_2.ReactNode;
     tooltip?: string;
-    thumbProps?: Switch_2.Thumb.Props;
     controlFirst?: boolean;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Outer flex wrapper that holds the switch and label. */
+        wrapper?: string;
+        /** Sliding thumb (knob) inside the switch. */
+        thumb?: string;
+        /** Label rendered next to the switch. */
+        label?: string;
+    };
 }
 
 export declare function SwitchRoot({ className, ...props }: Switch_2.Root.Props): React_2.ReactElement;
 
 export declare function SwitchThumb({ className, ...props }: Switch_2.Thumb.Props): React_2.ReactElement;
 
-export declare const TabContent: ({ value, ...props }: TabContentProps) => JSX.Element | null;
-
-export declare interface TabContentProps extends HTMLProps<HTMLDivElement> {
-    value: string;
-}
-
-export declare const Table: <T>({ data, columns, onRowClick, onDoubleClick, selected, theadClassName, theadProps, tbodyClassName, tbodyProps, trClassName, trProps, thClassName, thProps, tdClassName, tdProps, ...tableProps }: Props_11<T>) => JSX.Element;
+export declare function Table<T>({ data, columns, getRowKey, onRowClick, onRowDoubleClick, selected, classNames, ...tableProps }: TableProps<T>): JSX.Element;
 
-export declare const TABLE_PAGE_SIZES: number[];
+export declare function TableBody({ className, ...props }: React_2.ComponentProps<"tbody">): JSX.Element;
 
-export declare const TableBody: ({ className, ...props }: TableBodyProps) => JSX.Element;
+export declare function TableCaption({ className, ...props }: React_2.ComponentProps<"caption">): JSX.Element;
 
-declare type TableBodyProps = React_2.ComponentProps<"tbody">;
+export declare function TableCell({ className, ...props }: React_2.ComponentProps<"td">): JSX.Element;
 
-export declare const TableCaption: ({ className, ...props }: TableCaptionProps) => JSX.Element;
+export declare function TableFooter({ className, ...props }: React_2.ComponentProps<"tfoot">): JSX.Element;
 
-declare type TableCaptionProps = React_2.ComponentProps<"caption">;
+export declare function TableHead({ className, ...props }: React_2.ComponentProps<"th">): JSX.Element;
 
-export declare const TableCell: ({ className, ...props }: TableCellProps) => JSX.Element;
+export declare function TableHeader({ className, ...props }: React_2.ComponentProps<"thead">): JSX.Element;
 
-declare type TableCellProps = React_2.ComponentProps<"td">;
-
-export declare const TableFooter: ({ className, ...props }: TableFooterProps) => JSX.Element;
-
-declare type TableFooterProps = React_2.ComponentProps<"tfoot">;
-
-export declare const TableHead: ({ className, ...props }: TableHeadProps) => JSX.Element;
-
-export declare const TableHeader: ({ className, ...props }: TableHeaderProps) => JSX.Element;
-
-declare type TableHeaderProps = React_2.ComponentProps<"thead">;
-
-declare type TableHeadProps = React_2.ComponentProps<"th">;
-
-export declare const TablePagination: ({ containerClassName, containerProps, selectClassName, selectProps, sizes, ...props }: Props_12) => JSX.Element;
-
-declare interface TablePaginationExtendedProps {
-    containerClassName?: ClassName;
-    containerProps?: HTMLProps<HTMLDivElement>;
-    selectClassName?: ClassName;
-    selectProps?: HTMLProps<HTMLSelectElement>;
-    sizes?: PageSize[] | false;
-}
-
-declare type TableProps = React_2.ComponentProps<"table">;
+declare type TableProps<T> = {
+    data: T[];
+    columns: ColumnDef<T>[];
+    getRowKey?: (row: T, index: number) => string | number;
+    onRowClick?: (row: T) => void;
+    onRowDoubleClick?: (row: T) => void;
+    selected?: (row: T) => boolean;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Outer wrapper div with overflow handling. */
+        container?: string;
+        /** `<thead>` element. */
+        thead?: string;
+        /** `<tbody>` element. */
+        tbody?: string;
+        /** `<tr>` inside `<thead>` (the single header row). */
+        headerRow?: string;
+        /** Each `<tr>` inside `<tbody>` (the repeating body rows). */
+        tr?: string;
+        /** Header cell `<th>`. */
+        th?: string;
+        /** Body cell `<td>`. */
+        td?: string;
+    };
+} & Omit<React_2.ComponentProps<"table">, "onDoubleClick">;
 
-export declare const TableRoot: ({ className, containerClassName, containerProps, ...props }: TableRootProps) => JSX.Element;
+export declare function TableRoot({ className, classNames, ...props }: TableRootProps): JSX.Element;
 
-declare type TableRootProps = TableProps & {
-    containerClassName?: ContainerProps["className"];
-    containerProps?: ContainerProps;
+declare type TableRootProps = React_2.ComponentProps<"table"> & {
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Outer wrapper div with overflow handling. */
+        container?: string;
+    };
 };
 
-export declare const TableRow: ({ className, ...props }: TableRowProps) => JSX.Element;
+export declare function TableRow({ className, ...props }: React_2.ComponentProps<"tr">): JSX.Element;
 
-declare type TableRowProps = React_2.ComponentProps<"tr">;
+export declare function Tabs({ className, ...props }: TabsPrimitive.Root.Props): default_2.ReactElement;
 
-export declare const TabList: ({ children, className, indicatorClassName }: TabListProps) => JSX.Element;
-
-export declare interface TabListProps {
-    children: ReactNode;
-    className?: string;
-    indicatorClassName?: string;
-}
-
-export declare const Tabs: ({ children, value: prop, onChange, defaultValue, variant, ...props }: TabsProps) => JSX.Element;
-
-export declare interface TabsExtendedProps extends TabsProps {
-    listClassName: TabListProps["className"];
-    listProps: TabListProps;
-    triggerClassName: TabTriggerProps["className"];
-    triggerProps: TabTriggerProps;
-    contentClassName: TabContentProps["className"];
-    contentProps: TabContentProps;
-}
+declare function TabsList({ variant, centered, className, children, ...props }: TabsPrimitive.List.Props & {
+    variant?: TabsVariant;
+    centered?: boolean;
+}): default_2.ReactElement;
+export { TabsList as TabList }
+export { TabsList }
 
-export declare interface TabsProps extends Omit<HTMLProps<HTMLDivElement>, "value" | "defaultValue" | "onChange"> {
-    value?: string;
-    onChange?: (tab: string) => void;
-    defaultValue?: string;
-    variant?: "default" | "background";
-}
+declare function TabsPanel({ className, ...props }: TabsPrimitive.Panel.Props): default_2.ReactElement;
+export { TabsPanel as TabsContent }
+export { TabsPanel }
 
-export declare const TabTrigger: ({ value, className, ...props }: TabTriggerProps) => JSX.Element;
+export { TabsPrimitive }
 
-export declare interface TabTriggerProps extends Omit<HTMLProps<HTMLButtonElement>, "onClick" | "type"> {
-    value: string;
-}
+declare function TabsTab({ className, ...props }: TabsPrimitive.Tab.Props): default_2.ReactElement;
+export { TabsTab }
+export { TabsTab as TabsTrigger }
 
-export declare const Tag: ({ className, color, variant, rounded, icon, closable, onClose, children, ...props }: Props_13) => JSX.Element;
+export declare type TabsVariant = "underline" | "background";
 
-export declare type TagVariant = VariantProps<typeof tagVariants>;
+export declare function Tag({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof tagVariants>): ReactElement<unknown, string | JSXElementConstructor<any>>;
 
 export declare const tagVariants: (props?: ({
-    rounded?: "default" | "square" | "full" | null | undefined;
-    variant?: "error" | "success" | "outline" | "secondary" | "primary" | "borderless" | null | undefined;
+    variant?: "default" | "link" | "outline" | "secondary" | "ghost" | "error" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare function Textarea({ className, unstyled, ref, controlProps, ...props }: TextareaProps): ReactElement;
-
-export declare function TextareaControl({ className, unstyled, children, ...props }: ComponentProps<"span"> & {
-    unstyled?: boolean;
-}): ReactElement;
-
-export declare function TextareaField({ className, ref, onChange, ...props }: TextareaFieldProps): ReactElement;
-
-export declare type TextareaFieldProps = Omit<ComponentProps<"textarea">, "onChange"> & {
-    onChange?: (value: string, event: ChangeEvent<HTMLTextAreaElement>) => void;
-};
+export declare function Textarea({ className, onValueChange, ...props }: TextareaProps): ReactElement;
 
-export declare type TextareaProps = TextareaFieldProps & {
-    unstyled?: boolean;
-    controlProps?: ComponentProps<typeof TextareaControl>;
+export declare type TextareaProps = Omit<ComponentProps<"textarea">, "onChange"> & {
+    onValueChange?: (value: string, event: ChangeEvent<HTMLTextAreaElement>) => void;
 };
 
 export declare type Theme = {
@@ -1790,45 +2170,67 @@ declare type ThemeProviderProps = {
     theme?: Theme;
 };
 
-export declare const Timeline: ({ items, classNameContainer, containerProps, ...itemsProps }: TimelineProps) => JSX.Element;
+export declare function Timeline({ items, variant, classNames, ...props }: TimelineProps): JSX.Element;
 
-export declare const TimelineItemContent: (props: HTMLProps<HTMLDivElement>) => JSX.Element;
+export declare function TimelineContent({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
 
-export declare const TimelineItemDot: ({ icon, status, color, classNameDot, classNameContainerDot, }: TimelineItemDotProps) => JSX.Element;
+export declare function TimelineDate({ className, render, children, ...props }: useRender.ComponentProps<"time">): ReactElement<unknown, string | JSXElementConstructor<any>>;
 
-declare interface TimelineItemDotProps {
-    icon?: ReactNode;
-    status?: "done" | "pending" | "error";
-    color?: string;
-    classNameDot?: string;
-    classNameContainerDot?: string;
+export declare function TimelineHeader({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare function TimelineIndicator({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare function TimelineItem({ step, className, render, children, ...props }: TimelineItemProps): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+declare interface TimelineItemData {
+    title?: ReactNode;
+    content?: ReactNode;
+    date?: ReactNode;
+    indicator?: ReactNode;
 }
 
-export declare const TimelineListItem: ({ icon, status, color, classNameItemDot, classNameItemContainerDot, classNameItemContent, itemsProps, children, ...props }: TimelineListItemProps) => JSX.Element;
+declare interface TimelineItemProps extends useRender.ComponentProps<"div"> {
+    step: number;
+}
 
-declare interface TimelineListItemProps extends HTMLProps<HTMLLIElement> {
-    icon?: ReactNode;
-    status?: "done" | "pending" | "error";
-    color?: string;
-    itemsProps?: HTMLProps<HTMLDivElement>;
-    classNameContainer?: string;
-    classNameItemDot?: string;
-    classNameItemContainerDot?: string;
-    classNameItemContent?: string;
+declare type TimelineOrientation = "horizontal" | "vertical";
+
+declare interface TimelineProps extends Omit<TimelineRootProps, "children"> {
+    items: TimelineItemData[];
+    variant?: TimelineVariant;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Single timeline entry wrapper. */
+        item?: string;
+        /** Row that holds the indicator, date, and title. */
+        header?: string;
+        /** Title text inside the header. */
+        title?: string;
+        /** Date label inside the header. */
+        date?: string;
+        /** Body text below the header. */
+        content?: string;
+        /** Round dot marking the step. */
+        indicator?: string;
+        /** Line connecting consecutive items. */
+        separator?: string;
+    };
 }
 
-declare interface TimelineProps {
-    items: ItemTimeline[];
-    itemsProps?: HTMLProps<HTMLDivElement>;
-    containerProps?: HTMLProps<HTMLUListElement>;
-    classNameContainer?: string;
-    classNameItem?: string;
-    classNameItemDot?: string;
-    classNameItemContainerDot?: string;
-    classNameItemContent?: string;
+export declare function TimelineRoot({ defaultValue, value, onValueChange, orientation, className, render, children, ...props }: TimelineRootProps): JSX.Element;
+
+declare interface TimelineRootProps extends useRender.ComponentProps<"div"> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: TimelineOrientation;
 }
 
-export declare const TimelineRoot: (props: HTMLProps<HTMLUListElement>) => JSX.Element;
+export declare function TimelineSeparator({ className, render, children, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+export declare function TimelineTitle({ className, render, children, ...props }: useRender.ComponentProps<"h3">): ReactElement<unknown, string | JSXElementConstructor<any>>;
+
+declare type TimelineVariant = "default" | "alternate" | "date-left";
 
 /**
  * Imperative toast API. Works anywhere — no hook needed.
@@ -1927,7 +2329,7 @@ export declare function toastVariants({ variant, }?: {
  * </Tooltip>
  * ```
  */
-export declare function Tooltip({ content, children, open, defaultOpen, onOpenChange, side, align, offset, delay, closeDelay, className, arrowClassName, ...triggerProps }: TooltipProps): JSX.Element;
+export declare function Tooltip({ content, children, open, defaultOpen, onOpenChange, side, align, offset, delay, closeDelay, className, classNames, ...triggerProps }: TooltipProps): JSX.Element;
 
 export declare function TooltipArrow({ className, ...props }: ArrowProps): JSX.Element;
 
@@ -1950,14 +2352,16 @@ export declare type TooltipProps = Omit<RootProps, "children"> & Omit<TriggerPro
     delay?: TriggerProps["delay"];
     /** Delay in ms before the tooltip closes. @default 0 */
     closeDelay?: TriggerProps["closeDelay"];
-    /** Additional classes applied to the tooltip popup. */
+    /** Additional classes applied to the tooltip popup (visual root). */
     className?: string;
-    /**
-     * Additional classes applied to the arrow.
-     * Pass a `text-*` class to change the arrow color when overriding the popup background.
-     * @example arrowClassName="text-primary"
-     */
-    arrowClassName?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /**
+         * Arrow that points at the trigger. Pass a `text-*` class to change the
+         * arrow color when overriding the popup background.
+         */
+        arrow?: string;
+    };
 };
 
 /** Enables shared hover intent and delay grouping across multiple tooltips. */
@@ -1967,84 +2371,29 @@ export declare function TooltipRoot(props: RootProps): JSX.Element;
 
 export declare function TooltipTrigger({ className, ...props }: TriggerProps): JSX.Element;
 
-export declare function Tree<T extends TreeNode>({ items, ...props }: Props_14<T>): JSX.Element;
+export declare function TreeDragLine({ className, render, style, ...props }: useRender.ComponentProps<"div">): ReactElement<unknown, string | JSXElementConstructor<any>> | null;
 
-export declare const TreeItem: <T extends object>({ className, ...props }: OverrideProps<TreeItemProps<T>, {
-    id: string | number;
-}>) => JSX.Element;
+export declare function TreeItem<T>({ item, leafIcon, parentIcon, className, render, children, style, ...props }: TreeItemProps<T>): JSX.Element;
 
-export declare const TreeItemContent: (props: React_2.ComponentProps<typeof TreeItemContent_2>) => JSX.Element;
+export declare function TreeItemLabel({ className, render, children, ...props }: useRender.ComponentProps<"span">): ReactElement<unknown, string | JSXElementConstructor<any>>;
 
-export declare const TreeItemIndicator: () => JSX.Element;
-
-export declare const TreeItemLabel: (props: React_2.HtmlHTMLAttributes<HTMLSpanElement>) => JSX.Element;
-
-export declare interface TreeNode {
-    id: string | number;
-    title: string;
-    children: TreeNode[];
+export declare interface TreeItemProps<T> extends useRender.ComponentProps<"button"> {
+    item: ItemInstance<T>;
+    leafIcon?: ReactNode;
+    parentIcon?: ParentIcon;
 }
 
-export declare const TreeRoot: <T extends object>({ className, ...props }: TreeProps<T>) => JSX.Element;
+export declare function TreeRoot<T>({ tree, indent, className, render, style, ...props }: TreeRootProps<T>): JSX.Element;
 
-declare type TreeRootProps = React_2.ComponentProps<typeof TreeRoot>;
+export declare interface TreeRootProps<T> extends useRender.ComponentProps<"div"> {
+    tree: TreeInstance<T>;
+    indent?: number;
+}
 
 declare type TriggerProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Trigger>;
 
 export declare const twMerge: (...classLists: ClassNameValue[]) => string;
 
-export declare const type: (element: HTMLElement, value: string) => void;
-
-export declare const UploadAcceptedFiles: (props: UploadFilesProps) => JSX.Element;
-
-export declare const UploadContent: ({ className, ...props }: UploadContentProps) => JSX.Element;
-
-declare type UploadContentProps = ComponentPropsWithoutRef<"div"> & {
-    renderRejectedFile?: (file: File) => ReactNode;
-};
-
-declare type UploadFilesListProps = {
-    files: File[];
-    handleFileRemove: (index: number, type: "accepted" | "rejected") => void;
-    fileType: "accepted" | "rejected";
-    children?: ReactNode;
-    renderFile?: (file: File, removeItem: () => void) => ReactNode;
-};
-
-declare type UploadFilesProps = Omit<UploadFilesListProps, "fileType" | "handleFileRemove" | "files">;
-
-export declare const UploadItem: ({ file, onRemove, className, renderIcon, ...props }: UploadItemProps) => JSX.Element;
-
-declare type UploadItemProps = ComponentPropsWithoutRef<"div"> & {
-    file: File;
-    onRemove: () => void;
-    renderIcon?: (file: File) => ReactNode;
-};
-
-export declare const UploadRejectedFiles: (props: UploadFilesProps) => JSX.Element;
-
-export declare const UploadRoot: ({ onFileAdd, onFileRemove, onChangeFiles, files: prop, maxFiles, allowedExtensions, maxFileSize, multiple, children, onError, ...props }: UploadRootProps) => JSX.Element;
-
-declare type UploadRootProps = {
-    onFileAdd?: (files: File[]) => void;
-    onFileRemove?: (index: number, type: "accepted" | "rejected") => void;
-    onChangeFiles?: (files: File[]) => void;
-    files?: File[];
-    maxFiles?: number;
-    allowedExtensions?: string[];
-    maxFileSize?: number;
-    multiple?: true;
-    className?: string;
-    children?: ReactNode;
-    onError?: (fileErrors: FileError[]) => void;
-};
-
-export declare const UploadTrigger: ({ asChild, ...props }: UploadTriggerProps) => JSX.Element;
-
-declare type UploadTriggerProps = {
-    asChild?: boolean;
-} & ComponentPropsWithoutRef<"button">;
-
 export declare function useArray<T>(defaultProp: T[]): readonly [T[], {
     readonly insertAt: (index: number, item: T) => void;
     readonly removeAt: (index: number) => void;
@@ -2057,7 +2406,7 @@ export declare function useArray<T>(defaultProp: T[]): readonly [T[], {
     readonly update: (predicate: ListIterateeCustom<T, boolean>, newItem: T | ((item: T) => T)) => void;
 }];
 
-export declare function useAsync<T>({ fn, dependencies, onError, onSuccess, onFinish, }: Props_15<T>): AsyncState<T>;
+export declare function useAsync<T>({ fn, dependencies, onError, onSuccess, onFinish, }: Props_4<T>): AsyncState<T>;
 
 declare interface UseAsyncOptions<T> {
     onError?: (error: Error) => void;
@@ -2065,6 +2414,8 @@ declare interface UseAsyncOptions<T> {
     onFinish?: () => void;
 }
 
+export declare const useAutocompleteFilter: typeof AutocompletePrimitive.useFilter;
+
 export declare const useClickOutside: <T extends HTMLElement = HTMLElement>(callback: () => void, watch?: boolean) => RefObject<T | null>;
 
 export declare function useClipboard(): [CopiedValue, CopyFunction];
@@ -2090,8 +2441,12 @@ export declare function useDocumentTitle(title: string): void;
 
 export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): RefObject<T | null>;
 
+export declare function useFieldName(): string | undefined;
+
 export declare function useFocusTrap(active?: boolean): (instance: HTMLElement | null) => void;
 
+export declare function useHookForm<T extends FieldValues = FieldValues>(schema: z.ZodType<T>, options?: Partial<UseFormProps<T>>): UseFormReturn<T>;
+
 export declare function useHotkey(keys: string | string[], handler: (event: KeyboardEvent) => void, options?: HotkeyOptions): RefObject<any>;
 
 export declare function useHover<T extends HTMLElement>(options?: UseHoverOptions): {
@@ -2104,6 +2459,8 @@ declare type UseHoverOptions = {
     onHoverEnd?: (event: MouseEvent) => void;
 };
 
+export declare function useIsInsideFieldRoot(): boolean;
+
 export declare function useIsVisible<T extends HTMLElement>({ onVisible, root, rootMargin, threshold, }?: UseIsVisibleProps): UseIsVisibleReturn<T>;
 
 declare interface UseIsVisibleProps extends IntersectionObserverInit {
@@ -2143,7 +2500,7 @@ export declare function useObject<T extends GenericObject_2>(): MaybeReturn<T>;
 
 export declare function useObject<T extends GenericObject_2>(initialValue: T): Return<T>;
 
-export declare function usePagination({ totalItems, pageSize, initialCurrentPage, onChange, }: usePaginationProps): {
+export declare function usePagination({ totalItems, pageSize, currentPage: currentPageProp, defaultCurrentPage, onCurrentPageChange, initialCurrentPage, onChange, }: usePaginationProps): {
     next: () => void;
     prev: () => void;
     goTo: (page: number) => void;
@@ -2167,17 +2524,28 @@ export declare type usePaginationProps = {
      */
     pageSize: number;
     /**
-     * Pagina inicial
+     * Página controlada
+     */
+    currentPage?: number;
+    /**
+     * Página inicial (uncontrolled)
+     */
+    defaultCurrentPage?: number;
+    /**
+     * Callback cuando cambia la página
+     */
+    onCurrentPageChange?: (page: number) => void;
+    /**
+     * @deprecated Usá `defaultCurrentPage`
      */
     initialCurrentPage?: number;
     /**
-     * Callback que se ejecuta cuando cambia la pagina
+     * @deprecated Usá `onCurrentPageChange`
      */
     onChange?: (value: {
         currentPage: number;
         pageSize: number;
     }) => void;
-    siblingCount?: number;
 };
 
 export declare function usePortal(id: string): {
@@ -2224,6 +2592,10 @@ export declare function useSelection<T>(items: T[]): Return_2<T>;
 
 export declare function useStep<T = ReactNode>(steps: T[], amountSteps?: number): Return_3<T>;
 
+export declare function useStepItem(): StepItemContextValue;
+
+export declare function useStepper(): StepperContextValue;
+
 export declare const useTheme: () => {
     theme: Theme;
 };
@@ -2254,9 +2626,4 @@ export declare function useToggle(initialValue?: boolean): Return_4;
 
 export declare type ValuesUnion<T extends Record<string, any>> = T[keyof T];
 
-declare type VariantProps_2 = {
-    color?: never;
-    variant?: TagVariant["variant"];
-};
-
 export { }