@boxcustodia/library 1.10.2 → 2.0.0-alpha.10

package/dist/index.d.ts

@@ -1,4 +1,9 @@
+import { AlertDialog as AlertDialogPrimitive } from '@base-ui/react/alert-dialog';
+import { Avatar as AvatarPrimitive } from '@base-ui/react/avatar';
 import { ButtonHTMLAttributes } from 'react';
+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';
@@ -6,30 +11,28 @@ import { Collection } from 'react-aria-components';
 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 { default as default_2 } from 'react';
 import { DependencyList } from 'react';
-import * as DialogPrimitive from '@radix-ui/react-dialog';
-import { DialogProps } from '@radix-ui/react-dialog';
+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 { FieldError } from 'react-hook-form';
-import { FieldPath } from 'react-hook-form';
-import { FieldValues } from 'react-hook-form';
+import { Field as FieldPrimitive } from '@base-ui/react/field';
 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 { JSX } from 'react/jsx-runtime';
-import { JSXElementConstructor } from 'react';
 import { ListIterateeCustom } from 'lodash';
 import { LucideIcon } from 'lucide-react';
 import { LucideProps } from 'lucide-react';
 import { MutableRefObject } from 'react';
-import { Omit as Omit_2 } from 'lodash';
 import * as PopoverPrimitive from '@radix-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';
@@ -38,42 +41,110 @@ import { RefObject } from 'react';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import { SetStateAction } from 'react';
 import { Slot } from '@radix-ui/react-slot';
-import { StoreApi } from 'zustand';
-import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { Switch as Switch_2 } from '@base-ui/react/switch';
+import { ToastManager } from '@base-ui/react';
+import { ToastManagerAddOptions as ToastManagerAddOptions_2 } from '@base-ui/react/toast';
+import { ToastManagerPromiseOptions } from '@base-ui/react';
+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 { UseBoundStore } from 'zustand';
 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 const AlertDialog: ({ title, description, trigger, onClose, onAction, variant, triggerProps, contentProps, headerProps, titleProps, descriptionProps, footerProps, closeProps, closeText, actionText, actionProps, asChild, ...props }: AlertDialogProps) => JSX.Element;
+/**
+ * Accessible confirmation dialog with cancel and action buttons.
+ *
+ * The `trigger` prop uses Base UI's `render` prop — no wrapper element is added —
+ * making it composable with `<Tooltip>` at the primitive level.
+ * For full structural control, use the exported primitives directly.
+ *
+ * @example
+ * ```tsx
+ * <AlertDialog
+ *   trigger={<Button variant="error">Delete account</Button>}
+ *   title="Delete account?"
+ *   description="This action cannot be undone."
+ *   variant="error"
+ *   actionText="Delete"
+ *   onAction={handleDelete}
+ * />
+ * ```
+ */
+export declare function AlertDialog({ trigger, title, description, children, onClose, onAction, variant, closeText, actionText, className, ...props }: AlertDialogProps): JSX.Element;
+
+/** Semi-transparent overlay rendered behind the popup. */
+export declare function AlertDialogBackdrop({ className, ...props }: AlertDialogPrimitive.Backdrop.Props): JSX.Element;
 
-declare type AlertDialogProps = React.ComponentPropsWithoutRef<typeof DialogRoot> & {
-    title?: React.ReactNode;
-    description?: React.ReactNode;
-    trigger?: React.ReactNode;
+/** Closes the dialog and merges an optional `onClick` into the `render` element. */
+export declare function AlertDialogClose({ className, ...props }: AlertDialogPrimitive.Close.Props): JSX.Element;
+
+/** Supplementary description rendered below the title. */
+export declare function AlertDialogDescription({ className, ...props }: AlertDialogPrimitive.Description.Props): JSX.Element;
+
+/** Layout wrapper for action buttons. */
+export declare function AlertDialogFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+/** Layout wrapper for title and description. */
+export declare function AlertDialogHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
+
+/**
+ * Dialog content container. Includes Portal, Backdrop and Viewport internally.
+ * Pass `portalProps` to configure the portal (e.g. a custom `container`).
+ */
+export declare function AlertDialogPopup({ className, portalProps, ...props }: AlertDialogPrimitive.Popup.Props & {
+    portalProps?: AlertDialogPrimitive.Portal.Props;
+}): JSX.Element;
+
+export { AlertDialogPrimitive }
+
+export declare type AlertDialogProps = Omit<AlertDialogPrimitive.Root.Props, "children"> & {
+    /** Element that opens the dialog on click. Passed as Base UI `render` prop — no DOM wrapper added. */
+    trigger?: ReactElement;
+    /** Dialog heading. */
+    title?: ReactNode;
+    /** Supporting text rendered below the title. */
+    description?: ReactNode;
+    /** Custom content rendered between the description and the footer buttons. */
+    children?: ReactNode;
+    /** Called when the cancel button is clicked. */
     onClose?: () => void;
+    /** Called when the action button is clicked. */
     onAction?: () => void;
-    variant?: "default" | "error";
-    triggerProps?: ComponentProps<typeof DialogTrigger>;
-    contentProps?: ComponentProps<typeof DialogContent>;
-    headerProps?: ComponentProps<typeof DialogHeader>;
-    titleProps?: ComponentProps<typeof DialogTitle>;
-    descriptionProps?: ComponentProps<typeof DialogDescription>;
-    footerProps?: ComponentProps<typeof DialogFooter>;
-    closeProps?: ComponentProps<typeof DialogClose> & VariantProps<typeof Button>;
-    actionProps?: ComponentProps<typeof DialogClose> & VariantProps<typeof Button>;
-    closeText?: React.ReactNode;
-    actionText?: React.ReactNode;
-    asChild?: boolean;
+    /** Visual variant for the action button. @default "default" */
+    variant?: VariantProps<typeof buttonVariants>["variant"];
+    /** Label for the cancel button. @default "Cancel" */
+    closeText?: ReactNode;
+    /** Label for the action button. @default "Confirm" */
+    actionText?: ReactNode;
+    /** Additional className forwarded to the popup panel. */
+    className?: string;
 };
 
+/** Context root. Holds open state and wraps all dialog parts. */
+export declare function AlertDialogRoot(props: AlertDialogPrimitive.Root.Props): JSX.Element;
+
+/** Accessible title rendered as `<h2>`. Required for a11y. */
+export declare function AlertDialogTitle({ className, ...props }: AlertDialogPrimitive.Title.Props): JSX.Element;
+
+/**
+ * Renders as its `render` element (defaults to `<button>`).
+ * Because it uses Base UI's render prop — not Radix Slot — it composes cleanly
+ * with `<Tooltip>` and other Base UI triggers on the same DOM element.
+ */
+export declare function AlertDialogTrigger({ className, ...props }: AlertDialogPrimitive.Trigger.Props): JSX.Element;
+
+/** Full-screen container that centers the popup. */
+export declare function AlertDialogViewport({ className, ...props }: AlertDialogPrimitive.Viewport.Props): JSX.Element;
+
 export declare type ArrayUnion<V, T extends ReadonlyArray<V>> = T[number];
 
+declare type ArrowProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Arrow>;
+
 declare interface AsyncState<T> {
     loading: boolean;
     error: Error | null;
@@ -83,11 +154,11 @@ 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_3) => JSX.Element;
+export declare const AutoComplete: ({ items, placeholder, emptyMessage, onSelect, containerClassName, containerProps, inputClassName, inputProps, listClassName, listProps, itemClassName, itemProps, emptyClassName, emptyProps, }: Props) => JSX.Element;
 
 export declare const AutoCompleteDialog: ({ children, ...props }: AutoCompleteDialogProps) => JSX.Element;
 
-declare interface AutoCompleteDialogProps extends DialogProps {
+declare interface AutoCompleteDialogProps extends DialogProps_2 {
 }
 
 export declare const AutoCompleteEmpty: (props: React_2.ComponentProps<typeof Command.Empty>) => JSX.Element;
@@ -106,23 +177,35 @@ export declare const AutoCompleteSeparator: ({ className, ...props }: React_2.Co
 
 export declare const AutoCompleteShortcut: ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>) => JSX.Element;
 
-export declare const Avatar: ({ variant, size, fallback, alt, src, className, imageProps, ...props }: AvatarProps) => JSX.Element;
+export declare function Avatar({ src, alt, fallback, delay, shape, size, className, imageProps, fallbackProps, ...props }: AvatarProps): JSX.Element;
 
-declare type AvatarProps = OverrideProps<HTMLProps<HTMLDivElement>, VariantProps<typeof avatarVariants> & {
-    fallback?: ReactNode;
+export declare function AvatarFallback({ className, ...props }: AvatarPrimitive.Fallback.Props): JSX.Element;
+
+export declare function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props): JSX.Element;
+
+export { AvatarPrimitive }
+
+declare interface AvatarProps extends Omit<AvatarPrimitive.Root.Props, "children"> {
+    src?: string;
     alt: string;
-    src: string;
-    imageProps?: HTMLProps<HTMLImageElement>;
-}>;
+    fallback?: ReactNode;
+    delay?: AvatarPrimitive.Fallback.Props["delay"];
+    shape?: VariantProps<typeof avatarVariants>["shape"];
+    size?: VariantProps<typeof avatarVariants>["size"];
+    imageProps?: AvatarPrimitive.Image.Props;
+    fallbackProps?: AvatarPrimitive.Fallback.Props;
+}
+
+export declare function AvatarRoot({ className, shape, size, ...props }: AvatarPrimitive.Root.Props & VariantProps<typeof avatarVariants>): JSX.Element;
 
 declare const avatarVariants: (props?: ({
-    variant?: "circle" | "square" | null | undefined;
-    size?: "sm" | "lg" | "md" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+    size?: "sm" | "lg" | "xs" | "md" | "xl" | null | undefined;
 } & ClassProp) | undefined) => string;
 
-export declare const BackgroundImage: ({ src, ...props }: Props_4) => JSX.Element;
+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_2) => JSX.Element;
+export declare const BaseButton: ({ asChild, onClick, loading: prop, showLoader, icon, iconPosition, loaderReplace, style, ...props }: Props_4) => JSX.Element;
 
 declare type BaseButtonProps = ComponentProps<typeof BaseButton>;
 
@@ -131,16 +214,20 @@ export declare type BaseEntity = {
     createdAt: Date;
 };
 
-declare type BaseProps = {
+declare type BaseProps = FormPrimitive.Props;
+
+declare type BaseProps_2 = {
     icon?: React.ReactNode;
     rounded?: TagVariant["rounded"];
 } & StyleProps & React.HTMLAttributes<HTMLDivElement>;
 
-export declare const Button: (props: Props) => JSX.Element;
+export declare const Button: (props: Props_3) => JSX.Element;
 
 declare type ButtonProps = ComponentProps<typeof Button>;
 
-declare const buttonVariants: (props?: ({
+declare type ButtonProps_2 = 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;
@@ -212,9 +299,65 @@ export declare const CardHeader: ({ className, ...props }: default_2.HTMLAttribu
 
 export declare const CardTitle: ({ className, ...props }: default_2.HTMLAttributes<HTMLHeadingElement>) => JSX.Element;
 
-export declare const Center: ({ className, ...props }: ComponentPropsWithoutRef<"div">) => JSX.Element;
+export declare const Center: ({ as: Tag, inline, className, ...props }: CenterProps) => JSX.Element;
+
+declare interface CenterProps extends ComponentProps<"div"> {
+    as?: ElementType;
+    inline?: boolean;
+}
+
+export declare const Checkbox: typeof CheckboxSingle & {
+    Item: typeof CheckboxItem;
+    Group: typeof CheckboxGroup_2;
+    Legend: typeof CheckboxLegend;
+};
+
+export declare function CheckboxGroup({ className, ...props }: CheckboxGroup_3.Props): React_2.ReactElement;
+
+declare function CheckboxGroup_2({ legend, children, error, description, defaultValue, value, onChange, allValues, disabled, controlFirst, className, }: CheckboxGroupProps): React_2.ReactElement;
+
+export declare interface CheckboxGroupProps {
+    legend?: ReactNode;
+    children: ReactNode;
+    error?: string;
+    description?: ReactNode;
+    defaultValue?: string[];
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    allValues?: string[];
+    disabled?: boolean;
+    controlFirst?: boolean;
+    className?: string;
+}
+
+export declare function CheckboxIndicator({ className, ...props }: CheckboxPrimitive.Indicator.Props): React_2.ReactElement;
+
+declare function CheckboxItem({ className, label, id, ...props }: CheckboxItemProps): React_2.ReactElement;
+
+export declare interface CheckboxItemProps extends Omit<CheckboxPrimitive.Root.Props, "children"> {
+    label: ReactNode;
+}
+
+declare function CheckboxLegend({ children, className }: CheckboxLegendProps): React_2.ReactElement;
+
+export declare interface CheckboxLegendProps {
+    children: ReactNode;
+    className?: string;
+}
+
+export { CheckboxPrimitive }
 
-export declare const Checkbox: ({ checked, onChange, defaultChecked, indeterminate, defaultIndeterminate, onIndeterminateChange, className, size, children, containerClassName, containerProps, ...props }: Props_5) => JSX.Element;
+declare interface CheckboxProps extends Omit<CheckboxPrimitive.Root.Props, "children"> {
+    children?: ReactNode;
+    label?: ReactNode;
+    tooltip?: ReactNode;
+    indicatorProps?: CheckboxPrimitive.Indicator.Props;
+    controlFirst?: boolean;
+}
+
+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;
 
 export declare type ClassName = string | undefined;
 
@@ -222,7 +365,7 @@ export declare const click: (element: HTMLElement) => void;
 
 export declare type ClickEvent = React.MouseEvent<HTMLButtonElement, MouseEvent>;
 
-declare type ClosableProps = BaseProps & {
+declare type ClosableProps = BaseProps_2 & {
     closable: true;
     onClose: () => void;
 };
@@ -255,7 +398,7 @@ export declare type ColumnDef<T> = {
     width?: string | number;
 };
 
-export declare function Combobox<TItem extends Record<string, any>>({ items, valueKey, labelKey, placeholder, searchPlaceholder, emptyMessage, searchProps, className, triggerProps, itemProps, itemClassName, contentProps, contentClassName, value: prop, onChange, defaultValue: defaultProp, renderOption, commandProps, ...props }: Props_6<TItem>): JSX.Element;
+export declare function Combobox<TItem extends Record<string, any>>({ items, valueKey, labelKey, placeholder, searchPlaceholder, emptyMessage, searchProps, className, triggerProps, itemProps, itemClassName, contentProps, contentClassName, value: prop, onChange, defaultValue: defaultProp, renderOption, commandProps, ...props }: Props_5<TItem>): JSX.Element;
 
 declare type ContainerProps = React_2.ComponentProps<"div">;
 
@@ -273,11 +416,22 @@ declare type CopyFunction = (text: string) => Promise<boolean>;
 
 export declare const createSafeContext: <T>() => readonly [() => T & ({} | undefined), default_2.Provider<T | null>];
 
+export declare function createToastManager(): ToastManager<any> & {
+    close: (id?: string) => any;
+    add: (options: ToastManagerAddOptions<any>) => any;
+    update: (id: string, options: Partial<ToastManagerAddOptions<any>>) => any;
+    promise: <T>(promise: Promise<T>, options: {
+        loading: ToastManagerAddOptions<any>;
+        success: ToastManagerAddOptions<any> | ((data: T) => ToastManagerAddOptions<any>);
+        error: ToastManagerAddOptions<any> | ((error: Error) => ToastManagerAddOptions<any>);
+    }) => any;
+};
+
 export declare type DateMatcher = DateSingle | DateRange | DateMultiple;
 
 export declare type DateMultiple = Date[];
 
-export declare const DatePicker: (props: Props_8) => JSX.Element;
+export declare const DatePicker: (props: Props_7) => JSX.Element;
 
 export declare type DatePickerFooterProps = {
     mode: "single";
@@ -299,34 +453,94 @@ declare type DayProps = {
     navigationDate: Date;
 } & HTMLProps<HTMLButtonElement>;
 
-export declare const Dialog: ({ trigger, title, description, children, footer, focus, triggerProps, headerProps, headerClassName, titleProps, titleClassName, descriptionProps, descriptionClassName, contentProps, contentClassName, footerProps, footerClassName, ...props }: Props_9) => JSX.Element;
+/**
+ * General-purpose dialog with optional trigger, title, description, body, and footer.
+ *
+ * The `trigger` prop uses Base UI's `render` prop — no wrapper element is added —
+ * making it composable with `<Tooltip>` at the primitive level.
+ * For full structural control, use the exported primitives directly.
+ *
+ * @example
+ * ```tsx
+ * <Dialog
+ *   trigger={<Button>Open settings</Button>}
+ *   title="Settings"
+ *   description="Manage your account preferences."
+ *   footer={<Button onClick={handleSave}>Save</Button>}
+ * >
+ *   <SettingsForm />
+ * </Dialog>
+ * ```
+ */
+export declare function Dialog({ trigger, title, description, children, footer, onClose, hideClose, closeProps, portalProps, className, onOpenChange, ...props }: DialogProps): JSX.Element;
 
-export declare const DialogClose: ({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Close>) => JSX.Element;
+/** Semi-transparent overlay rendered behind the popup. */
+export declare function DialogBackdrop({ className, ...props }: DialogPrimitive.Backdrop.Props): JSX.Element;
 
-export declare const DialogContent: ({ className, children, focus, hideClose, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
-    focus?: boolean;
-    hideClose?: boolean;
-}) => JSX.Element;
+/** Closes the dialog and merges an optional `onClick` into the `render` element. */
+export declare function DialogClose({ className, ...props }: DialogPrimitive.Close.Props): JSX.Element;
 
-export declare const DialogDescription: ({ className, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>) => JSX.Element;
+/** Supplementary description rendered below the title. */
+export declare function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props): JSX.Element;
 
-export declare const DialogFooter: ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>) => JSX.Element;
+/** Layout wrapper for action buttons. */
+export declare function DialogFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
 
-export declare const DialogHeader: ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>) => JSX.Element;
+/** Layout wrapper for title and description. */
+export declare function DialogHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): JSX.Element;
 
-export declare const DialogOverlay: ({ className, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>) => JSX.Element;
+/**
+ * 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.
+ */
+export declare function DialogPopup({ className, children, hideClose, closeProps, portalProps, ...props }: DialogPrimitive.Popup.Props & {
+    hideClose?: boolean;
+    closeProps?: DialogPrimitive.Close.Props;
+    portalProps?: DialogPrimitive.Portal.Props;
+}): JSX.Element;
 
-export declare const DialogPortal: ({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Portal>) => JSX.Element;
+export { DialogPrimitive }
 
-export declare const DialogRoot: ({ onClose, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Root> & {
-    onClose?: () => any;
-}) => JSX.Element;
+export declare type DialogProps = Omit<DialogPrimitive.Root.Props, "children"> & {
+    /** Element that opens the dialog on click. Passed as Base UI `render` prop — no DOM wrapper added. */
+    trigger?: ReactElement;
+    /** Dialog heading. */
+    title?: ReactNode;
+    /** Supporting text rendered below the title. */
+    description?: ReactNode;
+    /** Body content rendered between the description and the footer. */
+    children?: ReactNode;
+    /** Content rendered inside the footer wrapper. */
+    footer?: ReactNode;
+    /** Called when the dialog closes. */
+    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. */
+    className?: string;
+};
+
+/** Context root. Holds open state and wraps all dialog parts. */
+export declare function DialogRoot(props: DialogPrimitive.Root.Props): JSX.Element;
 
-export declare const DialogTitle: ({ className, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>) => JSX.Element;
+/** Accessible title rendered as `<h2>`. Required for a11y. */
+export declare function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props): JSX.Element;
 
-export declare const DialogTrigger: ({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Trigger>) => JSX.Element;
+/**
+ * Renders as its `render` element (defaults to `<button>`).
+ * Composes cleanly with `<Tooltip>` and other Base UI triggers on the same DOM element.
+ */
+export declare function DialogTrigger({ className, ...props }: DialogPrimitive.Trigger.Props): JSX.Element;
 
-export declare const Divider: (props: Props_10) => JSX.Element;
+/** Full-screen container that centers the popup. */
+export declare function DialogViewport({ className, ...props }: DialogPrimitive.Viewport.Props): JSX.Element;
+
+export declare const Divider: (props: Props_8) => JSX.Element;
 
 export declare const DOTS = "...";
 
@@ -403,7 +617,7 @@ export declare type DropzoneProps = {
     onError?: (fileErrors: FileError[]) => void;
 } & Omit<ComponentPropsWithoutRef<"div">, "onDrop" | "onError">;
 
-export declare const EmptyState: ({ icon, title, description, className, children, ...props }: Props_11) => JSX.Element;
+export declare const EmptyState: ({ icon, title, description, className, children, ...props }: Props_9) => JSX.Element;
 
 export declare const ensureReactElement: <P>({ children, as: Wrapper, props, }: EnsureReactElementProps<P>) => ReactElement;
 
@@ -431,20 +645,6 @@ declare interface ExtendedProps {
 }
 
 declare interface ExtendedProps_2 {
-    triggerProps?: ComponentPropsWithoutRef<typeof DialogTrigger>;
-    headerProps?: ComponentPropsWithoutRef<typeof DialogHeader>;
-    headerClassName?: ClassName;
-    titleProps?: ComponentPropsWithoutRef<typeof DialogTitle>;
-    titleClassName?: ClassName;
-    descriptionProps?: ComponentPropsWithoutRef<typeof DialogDescription>;
-    descriptionClassName?: ClassName;
-    contentProps?: ComponentPropsWithoutRef<typeof DialogContent>;
-    contentClassName?: ClassName;
-    footerProps?: ComponentPropsWithoutRef<typeof DialogFooter>;
-    footerClassName?: ClassName;
-}
-
-declare interface ExtendedProps_3 {
     theadClassName?: ClassName;
     theadProps?: HTMLProps<HTMLTableSectionElement>;
     tbodyClassName?: ClassName;
@@ -464,7 +664,61 @@ declare interface ExtendedProps_3 {
  */
 export declare const extractInitials: (string: string) => string;
 
-export declare const Field: ({ label, labelClassName, labelProps, error, errorClassName, errorProps, children, className, ...props }: Props_12) => JSX.Element;
+export declare function Field({ label, description, error, required, tooltip, inline, children, className, labelProps, descriptionProps, errorProps, ...rootProps }: FieldProps): JSX.Element;
+
+export declare const FieldControl: typeof FieldPrimitive.Control;
+
+export declare function FieldDescription({ className, ...props }: FieldPrimitive.Description.Props): JSX.Element;
+
+export declare function FieldError({ className, ...props }: FieldPrimitive.Error.Props): JSX.Element;
+
+export declare type FieldErrorItem = {
+    message: ReactNode;
+    match?: NonNullable<FieldErrorMatch>;
+};
+
+export declare type FieldErrorMatch = FieldPrimitive.Error.Props["match"];
+
+export declare type FieldErrorProp = string | FieldErrorItem | FieldErrorItem[];
+
+export declare function FieldItem({ className, ...props }: FieldPrimitive.Item.Props): JSX.Element;
+
+export declare function FieldLabel({ className, ...props }: FieldPrimitive.Label.Props): JSX.Element;
+
+export { FieldPrimitive }
+
+export declare interface FieldProps extends Omit<FieldPrimitive.Root.Props, "children"> {
+    /** Text rendered inside `FieldLabel`. */
+    label?: ReactNode;
+    /** Helper text rendered below the control. */
+    description?: ReactNode;
+    /**
+     * Error message(s) rendered below the control:
+     * - `string` → always renders once the field is invalid.
+     * - `{ message, match }` → renders only when the `ValidityState` key matches.
+     * - `FieldErrorItem[]` → multiple errors with individual matches.
+     */
+    error?: FieldErrorProp;
+    /** Shows a red asterisk after the label text. */
+    required?: boolean;
+    /** Renders an info icon with a tooltip next to the label. */
+    tooltip?: ReactNode;
+    /**
+     * Renders the control before the label on the same row.
+     * Use for single checkboxes and switches.
+     */
+    inline?: boolean;
+    children?: ReactNode;
+    labelProps?: FieldPrimitive.Label.Props;
+    descriptionProps?: FieldPrimitive.Description.Props;
+    errorProps?: Omit<FieldPrimitive.Error.Props, "match" | "children">;
+}
+
+export declare function FieldRoot({ className, required, ...props }: FieldPrimitive.Root.Props & {
+    required?: boolean;
+}): JSX.Element;
+
+export declare const FieldValidity: typeof FieldPrimitive.Validity;
 
 declare type FileError = {
     file: File;
@@ -504,32 +758,14 @@ export declare const FileTypeGroups: Record<string, FileTypeValue[]>;
 
 export declare type FileTypeValue = (typeof FileType)[keyof typeof FileType];
 
-export declare const Form: <TFieldValues extends FieldValues = FieldValues>({ onSubmit, id, form, children, className, }: Props_13<TFieldValues>) => JSX.Element;
-
-export declare const FormControl: ({ className, ...props }: React_2.ComponentProps<typeof Slot>) => JSX.Element;
-
-export declare const FormDescription: ({ className, ...props }: React_2.ComponentProps<"p">) => JSX.Element;
-
-export declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, label, description, className, render, itemProps, labelProps, controlProps, descriptionProps, messageProps, }: FormFieldProps<TFieldValues, TName>) => JSX.Element;
-
-declare type FormFieldProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = {
-    name: TName;
-    label?: string;
-    description?: string;
-    render: (field: ControllerRenderProps<TFieldValues, TName>) => React_2.ReactNode;
-    className?: string;
-    itemProps?: React_2.ComponentProps<typeof FormItem>;
-    labelProps?: React_2.ComponentProps<typeof FormLabel>;
-    controlProps?: React_2.ComponentProps<typeof FormControl>;
-    descriptionProps?: React_2.ComponentProps<typeof FormDescription>;
-    messageProps?: React_2.ComponentProps<typeof FormMessage>;
-};
-
-export declare const FormItem: ({ className, ...props }: React_2.ComponentProps<"div">) => JSX.Element;
+export declare function Form({ onSubmit, onFormSubmit, className, ...props }: FormProps): default_2.ReactElement;
 
-export declare const FormLabel: ({ className, ...props }: React_2.ComponentProps<"label">) => JSX.Element;
+export { FormPrimitive }
 
-export declare const FormMessage: ({ className, children, ...props }: React_2.ComponentProps<"p">) => JSX.Element | null;
+export declare interface FormProps extends Omit<BaseProps, "onSubmit" | "onFormSubmit"> {
+    onSubmit?: BaseProps["onFormSubmit"];
+    onFormSubmit?: BaseProps["onFormSubmit"];
+}
 
 export declare interface GenericMenuProps {
     trigger: default_2.ReactNode;
@@ -547,7 +783,7 @@ 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_14<C>) => JSX.Element;
+export declare const Heading: <C extends React.ElementType = "h2">({ className, size, weight, as, ...props }: Props_10<C>) => JSX.Element;
 
 declare const HeadingVariants: (props?: ({
     size?: "sm" | "lg" | "md" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | null | undefined;
@@ -565,7 +801,14 @@ declare type HotkeyOptions = {
 
 export declare type ID = string | number;
 
-export declare const Input: ({ value: prop, onChange, defaultValue: defaultProp, ...rest }: Props_15) => JSX.Element;
+export declare function Input({ className, nativeInput, onChange, ...props }: InputProps): JSX.Element;
+
+export { InputPrimitive }
+
+export declare type InputProps = Omit<InputPrimitive.Props, "size" | "onChange"> & {
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    nativeInput?: boolean;
+};
 
 declare interface ItemTimeline {
     content?: ReactNode;
@@ -574,33 +817,53 @@ declare interface ItemTimeline {
     color?: string;
 }
 
-export declare interface IToast {
-    id: number | string;
-    title?: string;
-    description: ReactNode;
-    type: ToastType;
-}
+export declare function Kbd({ className, ...props }: React_2.ComponentProps<"kbd">): React_2.ReactElement;
 
-export declare const Kbd: ({ variant, size, className, ...props }: Props_16) => JSX.Element;
+export declare function KbdGroup({ className, ...props }: React_2.ComponentProps<"kbd">): React_2.ReactElement;
 
-export declare const KbdGroup: ({ className, ...props }: ComponentPropsWithoutRef<"kbd">) => JSX.Element;
+declare type Keys = string | string[];
 
-declare const KbdVariants: (props?: ({
-    variant?: "default" | "error" | "outline" | "secondary" | null | undefined;
-    size?: "default" | "sm" | "lg" | null | undefined;
-} & ClassProp) | undefined) => string;
+export declare function Label({ className, render, required, tooltip, children, ...props }: LabelProps): default_2.ReactElement;
 
-declare type Keys = string | string[];
+declare interface LabelProps extends useRender.ComponentProps<"label"> {
+    required?: boolean;
+    tooltip?: ReactNode;
+}
 
-export declare const Label: ({ className, ...props }: Props_17) => JSX.Element;
+/**
+ * Single provider that wires up all library infrastructure.
+ * Wrap your app once — no other providers needed.
+ *
+ * Includes:
+ * - `TooltipProvider` — shared hover intent and delay grouping across all tooltips
+ * - `ToastProvider` — enables `toast.*` imperative API from anywhere
+ *
+ * @example
+ * ```tsx
+ * <LibraryProvider tooltipDelay={400}>
+ *   <App />
+ * </LibraryProvider>
+ * ```
+ */
+export declare function LibraryProvider({ children, tooltipDelay, ...toastProps }: LibraryProviderProps): JSX.Element;
+
+export declare type LibraryProviderProps = {
+    children: ReactNode;
+    /**
+     * Delay in ms before a tooltip opens when no other tooltip is already visible.
+     * Once a tooltip is open, subsequent ones open instantly until the cursor leaves.
+     * @default 600
+     */
+    tooltipDelay?: ComponentPropsWithoutRef<typeof TooltipPrimitive.Provider>["delay"];
+} & Omit<ToastProviderProps, "children">;
 
-export declare const Loader: ({ center, containerClassName, variant, size, ...props }: Props_18) => JSX.Element;
+export declare const Loader: ({ center, containerClassName, variant, size, ...props }: Props_11) => JSX.Element;
 
 declare type LoaderVariants = VariantProps<typeof loaderVariants>;
 
 declare const loaderVariants: (props?: ({
-    variant?: "error" | "success" | "secondary" | "ghost" | "primary" | null | undefined;
-    size?: "default" | "sm" | "lg" | null | undefined;
+    variant?: "error" | "success" | "secondary" | "ghost" | "primary" | "warning" | "info" | null | undefined;
+    size?: "default" | "sm" | "lg" | "xs" | "xl" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export declare type Loose<T> = T | (string & {});
@@ -776,7 +1039,7 @@ declare type Mutation<TArgs extends any[], TReturn> = (...args: TArgs) => Promis
 
 declare type NavigationProps = Pick<CalendarNavigationProps, "goNextProps" | "goBackProps" | "changeViewProps">;
 
-declare type NonClosableProps = BaseProps & {
+declare type NonClosableProps = BaseProps_2 & {
     closable?: false;
     onClose?: never;
 };
@@ -785,7 +1048,7 @@ declare type noop = (this: any, ...args: any[]) => any;
 
 export declare type Nullable<T> = T | null;
 
-export declare const NumberInput: ({ value: prop, onChange, defaultValue: defaultProp, className, min, max, ...props }: Props_19) => JSX.Element;
+export declare const NumberInput: ({ value: prop, onChange, defaultValue: defaultProp, className, min, max, ...props }: Props_12) => JSX.Element;
 
 declare type OpenProps = {
     open?: boolean;
@@ -804,15 +1067,27 @@ export declare type OverrideProps<T, TOverridden> = Omit<T, keyof TOverridden> &
 
 export declare type PageSize = (typeof TABLE_PAGE_SIZES)[number];
 
-export declare const Pagination: ({ optionProps, className, containerProps, ...rangeProps }: Props_20) => JSX.Element;
+export declare const Pagination: ({ optionProps, className, containerProps, ...rangeProps }: Props_13) => JSX.Element;
 
 declare interface PaginationOptionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     isActive?: boolean;
 }
 
-export declare const Password: ({ className, containerClassName, showIcon, hideIcon, onShow, onHide, toggleable, ...rest }: Props_21) => JSX.Element;
+declare function Password({ className, showIcon, hideIcon, onShow, onHide, toggleable, onChange, ...rest }: PasswordProps): JSX.Element;
+export { Password }
+export { Password as PasswordRoot }
 
-export declare const Popover: (props: Props_22) => JSX.Element;
+declare type PasswordProps = Omit<InputProps, "unstyled" | "nativeInput"> & {
+    showIcon?: ReactNode;
+    hideIcon?: ReactNode;
+    onShow?: () => void;
+    onHide?: () => void;
+    toggleable?: boolean;
+};
+export { PasswordProps }
+export { PasswordProps as PasswordRootProps }
+
+export declare const Popover: (props: Props_14) => JSX.Element;
 
 export declare const PopoverContent: ({ className, align, sideOffset, matchTriggerWidth, style, focus, ...props }: PopoverContentProps) => JSX.Element;
 
@@ -825,58 +1100,52 @@ export declare const PopoverRoot: (props: React_2.ComponentProps<typeof PopoverP
 
 export declare const PopoverTrigger: (props: React_2.ComponentProps<typeof PopoverPrimitive.Trigger>) => JSX.Element;
 
-declare type Props = BaseButtonProps & VariantProps<typeof buttonVariants>;
+declare type PopupProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Popup>;
 
-declare type Props_10 = {
-    orientation?: "horizontal" | "vertical";
-} & HTMLProps<HTMLHRElement>;
+export declare function Progress({ size, variant, className, trackProps, indicatorProps, ...props }: ProgressProps): React_2.ReactElement;
 
-declare type Props_11 = ComponentPropsWithoutRef<"div"> & {
-    icon?: ReactNode;
-    title?: ReactNode;
-    description?: ReactNode;
-};
+export declare function ProgressIndicator({ className, variant, ...props }: Progress_2.Indicator.Props & VariantProps<typeof progressIndicatorVariants>): React_2.ReactElement;
 
-declare interface Props_12 extends ComponentProps<"div"> {
-    label?: ReactNode;
-    labelClassName?: string;
-    labelProps?: ComponentPropsWithoutRef<"label">;
-    error?: ReactNode;
-    errorClassName?: string;
-    errorProps?: ComponentPropsWithoutRef<"p">;
+declare const progressIndicatorVariants: (props?: ({
+    variant?: "default" | "error" | "success" | "warning" | "info" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare function ProgressLabel({ className, ...props }: Progress_2.Label.Props): React_2.ReactElement;
+
+declare interface ProgressProps extends Omit<Progress_2.Root.Props, "children"> {
+    size?: VariantProps<typeof progressTrackVariants>["size"];
+    variant?: VariantProps<typeof progressIndicatorVariants>["variant"];
+    trackProps?: Progress_2.Track.Props;
+    indicatorProps?: Progress_2.Indicator.Props;
 }
 
-declare type Props_13<TFieldValues extends FieldValues> = {
-    onSubmit: (data: TFieldValues) => void;
-    form: UseFormReturn<TFieldValues, any, any>;
-    children: React_2.ReactNode;
-    className?: string;
-    id?: string;
-};
+export declare function ProgressRoot({ className, ...props }: Progress_2.Root.Props): React_2.ReactElement;
 
-declare type Props_14<C extends React.ElementType> = VariantProps<typeof HeadingVariants> & {
-    as?: C;
-} & Omit<React.ComponentPropsWithoutRef<C>, "as">;
+export declare function ProgressTrack({ className, size, ...props }: Progress_2.Track.Props & VariantProps<typeof progressTrackVariants>): React_2.ReactElement;
 
-declare type Props_15 = OverrideProps<ComponentProps<"input">, {
-    /** valor del input */
-    value?: string;
-    /** functión a ejecutar cuando el valor cambia */
-    onChange?: (value: string) => void;
-    /** valor por defecto del input */
-    defaultValue?: string;
-}>;
+declare const progressTrackVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & ClassProp) | undefined) => string;
 
-declare type Props_16 = ComponentPropsWithoutRef<"kbd"> & VariantProps<typeof KbdVariants>;
+export declare function ProgressValue({ className, ...props }: Progress_2.Value.Props): React_2.ReactElement;
 
-declare type Props_17 = React_2.ComponentProps<"label">;
+declare interface Props extends ExtendedProps {
+    items: AutoCompleteItem[];
+    placeholder?: string;
+    emptyMessage?: string;
+    onSelect?: (value: AutoCompleteItem["value"], item: AutoCompleteItem) => any;
+}
 
-declare type Props_18 = LucideProps & LoaderVariants & {
+declare type Props_10<C extends React.ElementType> = VariantProps<typeof HeadingVariants> & {
+    as?: C;
+} & Omit<React.ComponentPropsWithoutRef<C>, "as">;
+
+declare type Props_11 = LucideProps & LoaderVariants & {
     center?: boolean;
     containerClassName?: string;
 };
 
-declare type Props_19 = OverrideProps<ComponentProps<"input">, {
+declare type Props_12 = OverrideProps<ComponentProps<"input">, {
     /** valor del input */
     value?: number;
     /** functión a ejecutar cuando el valor cambia */
@@ -889,37 +1158,13 @@ declare type Props_19 = OverrideProps<ComponentProps<"input">, {
     max?: number;
 }>;
 
-declare interface Props_2 extends ComponentProps<"button"> {
-    asChild?: boolean;
-    loading?: boolean;
-    showLoader?: boolean;
-    icon?: ReactNode;
-    iconPosition?: "start" | "end";
-    loaderReplace?: true;
-}
-
-declare interface Props_20 extends useRangePaginationProps {
+declare interface Props_13 extends useRangePaginationProps {
     optionProps?: PaginationOptionProps;
     className?: string;
     containerProps?: HTMLProps<HTMLDivElement>;
 }
 
-declare type Props_21 = OverrideProps<ComponentProps<typeof Input>, {
-    /** Clase CSS para el contenedor */
-    containerClassName?: string;
-    /** Ícono para mostrar la contraseña */
-    showIcon?: ReactNode;
-    /** Ícono para ocultar la contraseña */
-    hideIcon?: ReactNode;
-    /** Callback cuando se muestra la contraseña */
-    onShow?: () => void;
-    /** Callback cuando se oculta la contraseña */
-    onHide?: () => void;
-    /** Habilita/deshabilita el botón de mostrar/ocultar contraseña */
-    toggleable?: boolean;
-}>;
-
-declare interface Props_22 {
+declare interface Props_14 {
     trigger?: ReactNode;
     children: ReactNode;
     rootProps?: ComponentPropsWithoutRef<typeof PopoverRoot>;
@@ -933,133 +1178,59 @@ declare interface Props_22 {
     offset?: ComponentPropsWithoutRef<typeof PopoverContent>["sideOffset"];
 }
 
-declare interface Props_23 extends ComponentPropsWithoutRef<typeof Slot> {
+declare interface Props_15 extends ComponentPropsWithoutRef<typeof Slot> {
     /** Si el componente está presente o no */
     when: ComponentProps<typeof Presence>["present"];
 }
 
-declare interface Props_24 extends HTMLProps<HTMLDivElement> {
-    /**
-     * Determina si el skeleton es isCircle para redondearlo
-     */
-    isCircle?: boolean;
-    /**
-     * Ancho del componente
-     */
-    width?: string;
-    /**
-     * Alto del componente
-     */
-    height?: string;
-    /**
-     * Determina si el skeleton es visible
-     */
-    isLoading?: boolean;
-}
-
-declare type Props_25 = OverrideProps<ComponentProps<"input">, {
-    checked?: boolean;
-    onChange?: (value: boolean) => void;
-    defaultChecked?: boolean;
-    containerClassName?: string;
-    containerProps?: Omit<ComponentProps<"div">, "className">;
-}>;
-
-declare type Props_26<T> = {
+declare type Props_16<T> = {
     data: T[];
     columns: ColumnDef<T>[];
     onRowClick?: (row: T) => void;
     onDoubleClick?: (row: T) => void;
     selected?: (row: T) => boolean;
-} & ExtendedProps_3 & Omit<ComponentPropsWithoutRef<typeof TableRoot>, "data" | "selected" | "onDoubleClick">;
+} & ExtendedProps_2 & Omit<ComponentPropsWithoutRef<typeof TableRoot>, "data" | "selected" | "onDoubleClick">;
 
-declare type Props_27 = {
+declare type Props_17 = {
     setPageSize?: (value: PageSize) => void;
     pageSize?: PageSize;
 } & Omit<usePaginationProps, "pageSize"> & TablePaginationExtendedProps;
 
-declare type Props_28 = ClosableProps | NonClosableProps;
-
-declare type Props_29 = {
-    titleClassName?: ClassName;
-    titleProps?: HTMLProps<HTMLHeadingElement>;
-    descriptionClassName?: ClassName;
-    descriptionProps?: HTMLProps<HTMLParagraphElement>;
-    iconClassName?: ClassName;
-} & Omit_2<HTMLProps<HTMLDivElement>, "id"> & Omit_2<IToast, "id">;
+declare type Props_18 = ClosableProps | NonClosableProps;
 
-declare interface Props_3 extends ExtendedProps {
-    items: AutoCompleteItem[];
-    placeholder?: string;
-    emptyMessage?: string;
-    onSelect?: (value: AutoCompleteItem["value"], item: AutoCompleteItem) => any;
-}
-
-declare type Props_30 = ComponentProps<typeof TooltipTrigger> & {
-    /**
-     * El texto que aparecera en el tooltip
-     */
-    label: ReactNode;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => any;
-    side?: "top" | "right" | "bottom" | "left";
-    offset?: ComponentPropsWithoutRef<typeof TooltipContent>["sideOffset"];
-    arrowClassName?: string;
-};
-
-declare type Props_31<T extends TreeNode> = TreeRootProps & {
+declare type Props_19<T extends TreeNode> = TreeRootProps & {
     items: T[];
 };
 
-declare interface Props_32<T> extends UseAsyncOptions<T> {
-    fn: () => Promise<T>;
-    dependencies?: DependencyList;
-}
-
-declare interface Props_4 extends HTMLProps<HTMLDivElement> {
+declare interface Props_2 extends HTMLProps<HTMLDivElement> {
     /**
      * La URL de la imagen
      */
     src: string;
 }
 
-declare type Props_5 = OverrideProps<ComponentProps<"input">, {
-    /**
-     * Valor controlado del checkbox.
-     */
-    checked?: boolean;
-    /**
-     *  Función que se ejecuta cuando el valor del checkbox cambia.
-     */
-    onChange?: (value: boolean) => void;
-    /**
-     * Valor por defecto del checkbox.
-     */
-    defaultChecked?: boolean;
-    /**
-     * Estado indeterminado controlado del checkbox.
-     */
-    indeterminate?: boolean;
-    /**
-     * Valor por defecto del estado indeterminado.
-     */
-    defaultIndeterminate?: boolean;
-    /**
-     * Función que se ejecuta cuando el estado indeterminado cambia.
-     */
-    onIndeterminateChange?: (value: boolean) => void;
-    size?: string | number;
-    containerClassName?: string;
-    containerProps?: Omit<ComponentProps<"div">, "className">;
-}>;
+declare interface Props_20<T> extends UseAsyncOptions<T> {
+    fn: () => Promise<T>;
+    dependencies?: DependencyList;
+}
+
+declare type Props_3 = BaseButtonProps & VariantProps<typeof buttonVariants>;
+
+declare interface Props_4 extends ComponentProps<"button"> {
+    asChild?: boolean;
+    loading?: boolean;
+    showLoader?: boolean;
+    icon?: ReactNode;
+    iconPosition?: "start" | "end";
+    loaderReplace?: true;
+}
 
-declare type Props_6<TItem extends Record<string, any>> = {
+declare type Props_5<TItem extends Record<string, any>> = {
     emptyMessage?: string;
     commandProps?: ComponentProps<typeof AutoCompleteRoot>;
 } & SearchProps & SelectProps<TItem>;
 
-declare type Props_7<TItem extends Record<string, any>> = OverrideProps<ComponentProps<typeof SelectRoot> & Omit<ControllableState<string>, "onChange">, {
+declare type Props_6<TItem extends Record<string, any>> = OverrideProps<ComponentProps<typeof SelectRoot> & Omit<ControllableState<string>, "onChange">, {
     onChange?: (value: string, item: TItem) => void;
     /**
      * Listado de elementos a mostrar
@@ -1090,7 +1261,7 @@ declare type Props_7<TItem extends Record<string, any>> = OverrideProps<Componen
     placeholder?: string;
 }>;
 
-declare type Props_8 = ComponentProps<"input"> & {
+declare type Props_7 = ComponentProps<"input"> & {
     value?: Date | null;
     defaultValue?: Date | null;
     onChange?: (value: Date | null) => void;
@@ -1099,17 +1270,20 @@ declare type Props_8 = ComponentProps<"input"> & {
     renderFooter?: (props: DatePickerFooterProps) => ReactNode;
 };
 
-declare type Props_9 = ComponentPropsWithoutRef<typeof DialogRoot> & ExtendedProps_2 & {
-    trigger?: ReactNode;
+declare type Props_8 = {
+    orientation?: "horizontal" | "vertical";
+} & HTMLProps<HTMLHRElement>;
+
+declare type Props_9 = ComponentPropsWithoutRef<"div"> & {
+    icon?: ReactNode;
     title?: ReactNode;
     description?: ReactNode;
-    children: ReactNode;
-    footer?: ReactNode;
-    focus?: boolean;
 };
 
 declare type PropsWithoutValue<T> = Omit<T, "value" | "onChange" | "defaultValue">;
 
+declare type ProviderProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Provider>;
+
 export declare type RangeDateValue = {
     value?: DateRange;
     defaultValue?: DateRange;
@@ -1187,6 +1361,8 @@ declare interface Return_3<T = ReactNode> {
 
 declare type Return_4 = [boolean, (newValue?: boolean) => void];
 
+declare type RootProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Root>;
+
 export declare type SafeOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
 declare interface SearchProps {
@@ -1197,7 +1373,7 @@ declare interface SearchProps {
     searchPlaceholder?: string;
 }
 
-export declare const Select: <TItem extends Record<string, any> = Option_2>({ items, valueKey, labelKey, value: prop, onChange, defaultValue: defaultProp, renderOption, triggerProps, contentClassName, contentProps, itemClassName, itemProps, className, placeholder, ...props }: Props_7<TItem>) => JSX.Element;
+export declare const Select: <TItem extends Record<string, any> = Option_2>({ items, valueKey, labelKey, value: prop, onChange, defaultValue: defaultProp, renderOption, triggerProps, contentClassName, contentProps, itemClassName, itemProps, className, placeholder, ...props }: Props_6<TItem>) => JSX.Element;
 
 export declare const SelectContent: ({ className, children, position, ...props }: SelectContentProps) => JSX.Element;
 
@@ -1247,7 +1423,7 @@ declare type Shortcut = Partial<{
     shortcutOptions: MenuShortcutProps_2["options"];
 }>;
 
-export declare const Show: ({ when, ...props }: Props_23) => JSX.Element;
+export declare const Show: ({ when, ...props }: Props_15) => JSX.Element;
 
 export declare type SingleDateValue = {
     value?: DateSingle;
@@ -1255,16 +1431,20 @@ export declare type SingleDateValue = {
     onChange?: (date: DateSingle) => void;
 };
 
-export declare const Skeleton: ({ isCircle, width, height, isLoading, ...props }: Props_24) => string | number | bigint | true | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element;
+export declare function Skeleton({ className, ...props }: ComponentProps<"div">): JSX.Element;
 
-export declare const Stack: ({ inline, justify, align, direction, gap, style, ...props }: StackProps) => JSX.Element;
+export declare const Stack: ({ as: Tag, inline, direction, reverse, justify, align, gap, wrap, grow, className, style, ...props }: StackProps) => JSX.Element;
 
 declare interface StackProps extends ComponentProps<"div"> {
+    as?: ElementType;
     inline?: boolean;
+    direction?: "horizontal" | "vertical";
+    reverse?: boolean;
     justify?: CSSProperties["justifyContent"];
     align?: CSSProperties["alignItems"];
-    direction?: "horizontal" | "vertical";
     gap?: CSSProperties["gap"];
+    wrap?: CSSProperties["flexWrap"];
+    grow?: boolean;
 }
 
 export declare type State<T> = [T, SetState<T>];
@@ -1323,7 +1503,18 @@ declare interface StepperTriggerProps {
 
 declare type StyleProps = ColorProps | VariantProps_2;
 
-export declare const Switch: ({ className, children, containerProps, containerClassName, ...props }: Props_25) => JSX.Element;
+export declare function Switch({ children, label, className, id, thumbProps, controlFirst, ...props }: SwitchProps): React_2.ReactElement;
+
+declare interface SwitchProps extends Omit<Switch_2.Root.Props, "children"> {
+    children?: React_2.ReactNode;
+    label?: React_2.ReactNode;
+    thumbProps?: Switch_2.Thumb.Props;
+    controlFirst?: boolean;
+}
+
+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;
 
@@ -1331,7 +1522,7 @@ 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_26<T>) => JSX.Element;
+export declare const Table: <T>({ data, columns, onRowClick, onDoubleClick, selected, theadClassName, theadProps, tbodyClassName, tbodyProps, trClassName, trProps, thClassName, thProps, tdClassName, tdProps, ...tableProps }: Props_16<T>) => JSX.Element;
 
 export declare const TABLE_PAGE_SIZES: number[];
 
@@ -1359,7 +1550,7 @@ 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_27) => JSX.Element;
+export declare const TablePagination: ({ containerClassName, containerProps, selectClassName, selectProps, sizes, ...props }: Props_17) => JSX.Element;
 
 declare interface TablePaginationExtendedProps {
     containerClassName?: ClassName;
@@ -1414,7 +1605,7 @@ export declare interface TabTriggerProps extends Omit<HTMLProps<HTMLButtonElemen
     value: string;
 }
 
-export declare const Tag: ({ className, color, variant, rounded, icon, closable, onClose, children, ...props }: Props_28) => JSX.Element;
+export declare const Tag: ({ className, color, variant, rounded, icon, closable, onClose, children, ...props }: Props_18) => JSX.Element;
 
 export declare type TagVariant = VariantProps<typeof tagVariants>;
 
@@ -1432,7 +1623,6 @@ declare type TextAreaProps = Omit<HTMLProps<HTMLTextAreaElement>, "onChange"> &
 export declare type Theme = {
     Button?: ThemeProps<ComponentProps<typeof Button>, "asChild" | "loading">;
     Input?: Partial<PropsWithoutValue<ComponentProps<typeof Input>>>;
-    Tooltip?: ThemeProps<ComponentProps<typeof Tooltip>, "label" | "open" | "defaultOpen" | "onOpenChange">;
     Popover?: ThemeProps<ComponentProps<typeof Popover>, "open" | "defaultOpen" | "onOpenChange" | "trigger">;
 };
 
@@ -1485,60 +1675,144 @@ declare interface TimelineProps {
 
 export declare const TimelineRoot: (props: HTMLProps<HTMLUListElement>) => JSX.Element;
 
-export declare const Toast: ({ title, description, type, iconClassName, ...props }: Props_29) => JSX.Element;
-
-export declare const toast: ((args: ToastProperties) => number) & {
-    info: (args: ToastArgs) => number;
-    success: (args: ToastArgs) => number;
-    error: (args: ToastArgs) => number;
-    promise: <T>(promise: Promise<T>, options: ToastPromiseOptions<T>) => Promise<T>;
+/**
+ * Imperative toast API. Works anywhere — no hook needed.
+ *
+ * Requires `<ToastProvider>` somewhere in the tree (no extra props needed).
+ *
+ * @example
+ * ```ts
+ * toast("Notificación");                          // default variant
+ * toast.success("Guardado correctamente");
+ * toast.error({ title: "Error", description: "Algo salió mal" });
+ * toast.promise(saveData(), {
+ *   loading: { description: "Guardando..." },
+ *   success: () => ({ variant: "success", description: "Guardado!" }),
+ *   error:   (e) => ({ variant: "error",   description: e.message }),
+ * });
+ * ```
+ */
+export declare const toast: ((arg: ToastArg) => string | undefined) & {
+    success: (arg: ToastArg) => any;
+    error: (arg: ToastArg) => any;
+    warning: (arg: ToastArg) => any;
+    info: (arg: ToastArg) => any;
+    promise: <T>(promise: Promise<T>, options: {
+        loading: ToastManagerAddOptions<any>;
+        success: ToastManagerAddOptions<any> | ((data: T) => ToastManagerAddOptions<any>);
+        error: ToastManagerAddOptions<any> | ((error: Error) => ToastManagerAddOptions<any>);
+    }) => any;
 };
 
-export declare type ToastArgs = string | Omit<ToastProperties, "type">;
+declare type ToastArg = string | Omit<ToastManagerAddOptions<any>, "variant">;
 
-export declare const Toaster: ({ iconClassName, ...props }: ToasterProps) => JSX.Element;
+export declare type ToastManagerAddOptions<Data extends object = object> = ToastManagerAddOptions_2<Data> & ToastOptionsBase;
 
-export declare type ToasterProps = React.ComponentProps<"div"> & {
-    iconClassName?: string;
-};
+export declare type ToastOptions<Data extends object = object> = ToastObject<Data> & ToastOptionsBase;
 
-export declare const ToastIcons: Record<ToastType, ComponentType<LucideProps>>;
+declare type ToastOptionsBase = {
+    variant?: ToastVariant;
+    content?: ReactNode;
+    actions?: ButtonProps_2[];
+    bump?: boolean;
+};
 
-export declare interface ToastPromiseOptions<T> {
-    loading: string;
-    success: string | ((data: T) => string);
-    error: string | ((error: any) => string);
-}
+export { ToastPrimitive }
 
-export declare interface ToastProperties extends Omit<IToast, "id"> {
-    duration?: number;
-}
+/**
+ * ToastProvider — wrap your app once to enable toast notifications.
+ *
+ * Toasts stack in the bottom-right corner with swipe-to-dismiss and expand-on-hover.
+ * Once mounted, call `toast.success()` / `toast.error()` etc. from anywhere.
+ *
+ * @example
+ * ```tsx
+ * // app.tsx — one-time setup, no extra props needed
+ * <ToastProvider>
+ *   <App />
+ * </ToastProvider>
+ *
+ * // Anywhere in the codebase
+ * import { toast } from "@boxcustodia/library";
+ * toast.success("Cambios guardados");
+ * toast.error({ title: "Error", description: "Algo salió mal" });
+ * ```
+ */
+export declare function ToastProvider({ children, toastManager, container }: ToastProviderProps): JSX.Element;
 
-declare interface ToastStore {
-    toasts: IToast[];
-    addToast: (toast: Omit<IToast, "id"> & {
-        duration?: number;
-    }) => number;
-    removeToast: (id: number) => void;
-    updateToast: (id: number, toast: Partial<Omit<IToast, "id">>) => void;
-    promise: <T>(promise: Promise<T>, options: ToastPromiseOptions<T>) => Promise<T>;
+export declare interface ToastProviderProps {
+    children: ReactNode;
+    /**
+     * External toast manager created with `createToastManager()`.
+     * Only needed for isolated instances (tests, microfrontends).
+     * The default `<ToastProvider>` (no props) is all you need for `toast.*` to work.
+     */
+    toastManager?: ReturnType<typeof ToastPrimitive.createToastManager>;
+    /**
+     * Container element for the portal.
+     * @default document.body
+     */
+    container?: HTMLElement | null;
 }
 
-export declare type ToastType = "info" | "success" | "error" | "loading";
+export declare type ToastVariant = "default" | "success" | "error" | "warning" | "info";
 
-export declare const Tooltip: ({ label, open: prop, defaultOpen: defaultProp, onOpenChange: onChange, ...rest }: Props_30) => JSX.Element;
+export declare function toastVariants({ variant }?: {
+    variant?: ToastVariant;
+}): string;
 
-export declare const TooltipContent: ({ className, sideOffset, children, arrowClassName, ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Content> & {
+/**
+ * Accessible popup that shows additional information on hover/focus.
+ * Wrap your app or section with `<TooltipProvider>` to enable delay grouping.
+ *
+ * @example
+ * ```tsx
+ * <Tooltip content="Save changes">
+ *   <Button>Save</Button>
+ * </Tooltip>
+ * ```
+ */
+export declare function Tooltip({ content, children, open, defaultOpen, onOpenChange, side, align, offset, delay, closeDelay, className, arrowClassName, ...triggerProps }: TooltipProps): JSX.Element;
+
+export declare function TooltipArrow({ className, ...props }: ArrowProps): JSX.Element;
+
+export declare function TooltipPopup({ className, ...props }: PopupProps): JSX.Element;
+
+export { TooltipPrimitive }
+
+export declare type TooltipProps = Omit<RootProps, "children"> & Omit<TriggerProps, "render" | "delay" | "closeDelay" | "className" | "content"> & {
+    /** The element that triggers the tooltip on hover/focus. */
+    children: ReactElement;
+    /** Content displayed inside the tooltip popup. */
+    content: ReactNode;
+    /** Preferred side of the trigger to render the tooltip. @default "top" */
+    side?: "top" | "bottom" | "left" | "right";
+    /** Alignment on the axis perpendicular to `side`. @default "center" */
+    align?: "start" | "center" | "end";
+    /** Distance in pixels between the tooltip and the trigger. @default 10 */
+    offset?: number;
+    /** Delay in ms before the tooltip opens. @default 600 */
+    delay?: TriggerProps["delay"];
+    /** Delay in ms before the tooltip closes. @default 0 */
+    closeDelay?: TriggerProps["closeDelay"];
+    /** Additional classes applied to the tooltip popup. */
+    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;
-}) => JSX.Element;
+};
 
-export declare const TooltipProvider: ({ delayDuration, ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Provider>) => JSX.Element;
+/** Enables shared hover intent and delay grouping across multiple tooltips. */
+export declare function TooltipProvider(props: ProviderProps): JSX.Element;
 
-export declare const TooltipRoot: ({ ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Root>) => JSX.Element;
+export declare function TooltipRoot(props: RootProps): JSX.Element;
 
-export declare const TooltipTrigger: ({ ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Trigger>) => JSX.Element;
+export declare function TooltipTrigger({ className, ...props }: TriggerProps): JSX.Element;
 
-export declare function Tree<T extends TreeNode>({ items, ...props }: Props_31<T>): JSX.Element;
+export declare function Tree<T extends TreeNode>({ items, ...props }: Props_19<T>): JSX.Element;
 
 export declare const TreeItem: <T extends object>({ className, ...props }: OverrideProps<TreeItemProps<T>, {
     id: string | number;
@@ -1560,6 +1834,8 @@ export declare const TreeRoot: <T extends object>({ className, ...props }: TreeP
 
 declare type TreeRootProps = React_2.ComponentProps<typeof TreeRoot>;
 
+declare type TriggerProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Trigger>;
+
 export declare const twMerge: (...classLists: ClassNameValue[]) => string;
 
 export declare const type: (element: HTMLElement, value: string) => void;
@@ -1626,7 +1902,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_32<T>): AsyncState<T>;
+export declare function useAsync<T>({ fn, dependencies, onError, onSuccess, onFinish, }: Props_20<T>): AsyncState<T>;
 
 declare interface UseAsyncOptions<T> {
     onError?: (error: Error) => void;
@@ -1659,21 +1935,6 @@ export declare function useEventListener<K extends keyof HTMLElementEventMap, T
 
 export declare function useFocusTrap(active?: boolean): (instance: HTMLElement | null) => void;
 
-export declare function useForm<T extends FieldValues = FieldValues>(schema: z.ZodType<T>, options?: Partial<UseFormProps<T>>): UseFormReturn<T, any, T>;
-
-export declare const useFormField: () => {
-    invalid: boolean;
-    isDirty: boolean;
-    isTouched: boolean;
-    isValidating: boolean;
-    error?: FieldError;
-    id: string;
-    name: string;
-    formItemId: string;
-    formDescriptionId: string;
-    formMessageId: string;
-};
-
 export declare function useHotkey(keys: string | string[], handler: (event: KeyboardEvent) => void, options?: HotkeyOptions): RefObject<any>;
 
 export declare function useHover<T extends HTMLElement>(options?: UseHoverOptions): {
@@ -1820,7 +2081,17 @@ export declare const useTheme: () => {
  */
 export declare const useThemeProps: <TComponent extends keyof Theme, TProps>(componentName: TComponent, props: TProps, defaultProps?: Partial<TProps>) => TProps;
 
-export declare const useToastStore: UseBoundStore<StoreApi<ToastStore>>;
+export declare function useToastManager(): {
+    toasts: ToastOptions<any>[];
+    add: (<T extends any = any>(options: ToastManagerAddOptions_2<T>) => string) & ((options: ToastManagerAddOptions<any>) => any);
+    close: ((toastId?: string) => void) & ((id?: string) => any);
+    update: (<T extends any = any>(toastId: string, options: ToastManagerUpdateOptions<T>) => void) & ((id: string, options: Partial<ToastManagerAddOptions<any>>) => any);
+    promise: (<Value, T extends any = any>(promise: Promise<Value>, options: ToastManagerPromiseOptions<Value, T>) => Promise<Value>) & (<T>(promise: Promise<T>, options: {
+        loading: ToastManagerAddOptions<any>;
+        success: ToastManagerAddOptions<any> | ((data: T) => ToastManagerAddOptions<any>);
+        error: ToastManagerAddOptions<any> | ((error: Error) => ToastManagerAddOptions<any>);
+    }) => any);
+};
 
 export declare function useToggle(initialValue?: boolean): Return_4;