@boxcustodia/library 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/src/components/select/select.d.ts

@@ -0,0 +1,71 @@
+import { Select as SelectPrimitive } from '@base-ui/react/select';
+import { useRender } from '@base-ui/react/use-render';
+import * as React from "react";
+export declare const selectTriggerClasses: string;
+export declare const selectTriggerIconClassName = "-me-1 size-4.5 opacity-80 sm:size-4";
+export declare function SelectRoot<Value = string, Multiple extends boolean | undefined = false>({ ...props }: SelectPrimitive.Root.Props<Value, Multiple>): React.ReactElement;
+export declare function SelectTrigger({ className, children, ...props }: SelectPrimitive.Trigger.Props): React.ReactElement;
+export type SelectButtonProps = useRender.ComponentProps<"button"> & {
+    ref?: React.Ref<HTMLButtonElement>;
+};
+export declare function SelectButton({ className, render, children, ...props }: SelectButtonProps): React.ReactElement;
+export declare function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): React.ReactElement;
+export declare function SelectPopup({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, anchor, portalProps, ...props }: SelectPrimitive.Popup.Props & {
+    portalProps?: SelectPrimitive.Portal.Props;
+    side?: SelectPrimitive.Positioner.Props["side"];
+    sideOffset?: SelectPrimitive.Positioner.Props["sideOffset"];
+    align?: SelectPrimitive.Positioner.Props["align"];
+    alignOffset?: SelectPrimitive.Positioner.Props["alignOffset"];
+    alignItemWithTrigger?: SelectPrimitive.Positioner.Props["alignItemWithTrigger"];
+    anchor?: SelectPrimitive.Positioner.Props["anchor"];
+}): React.ReactElement;
+export declare function SelectItem({ className, children, ...props }: SelectPrimitive.Item.Props): React.ReactElement;
+export declare function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): React.ReactElement;
+export declare function SelectGroup(props: SelectPrimitive.Group.Props): React.ReactElement;
+export declare function SelectGroupLabel(props: SelectPrimitive.GroupLabel.Props): React.ReactElement;
+export declare function SelectLabel({ className, ...props }: SelectPrimitive.Label.Props): React.ReactElement;
+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;
+    /** 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.ReactNode;
+    placeholder?: string;
+    className?: string;
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Popup panel containing the item list. */
+        popup?: string;
+        /** Individual item row. */
+        item?: string;
+    };
+};
+export type SelectProps<TItem = unknown> = (SelectBaseProps<TItem> & {
+    multiple?: false;
+    value?: TItem | null;
+    defaultValue?: TItem | null;
+    onValueChange?: (value: TItem | null) => void;
+}) | (SelectBaseProps<TItem> & {
+    multiple: true;
+    value?: TItem[];
+    defaultValue?: TItem[];
+    onValueChange?: (value: TItem[]) => void;
+});
+/**
+ * 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 `className` + `classNames` slots offer.
+ */
+export declare function Select<TItem = unknown>(allProps: SelectProps<TItem>): React.ReactElement;
+export { SelectPrimitive };
+export { SelectPopup as SelectContent };

package/dist/src/components/select/select.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/skeleton/index.d.ts

@@ -0,0 +1 @@
+export * from './skeleton';

package/dist/src/components/skeleton/skeleton.d.ts

@@ -0,0 +1,2 @@
+import { ComponentProps } from 'react';
+export declare function Skeleton({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/skeleton/skeleton.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/stack/index.d.ts

@@ -0,0 +1 @@
+export * from './stack';

package/dist/src/components/stack/stack.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProps, CSSProperties, ElementType } from 'react';
+interface StackProps extends ComponentProps<"div"> {
+    as?: ElementType;
+    inline?: boolean;
+    direction?: "horizontal" | "vertical";
+    reverse?: boolean;
+    justify?: CSSProperties["justifyContent"];
+    align?: CSSProperties["alignItems"];
+    gap?: CSSProperties["gap"];
+    wrap?: CSSProperties["flexWrap"] | boolean;
+    grow?: boolean;
+}
+export declare const Stack: ({ as: Tag, inline, direction, reverse, justify, align, gap, wrap, grow, className, style, ...props }: StackProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/stack/stack.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/stepper/index.d.ts

@@ -0,0 +1 @@
+export * from './stepper';

package/dist/src/components/stepper/stepper.d.ts

@@ -0,0 +1,83 @@
+import { useRender } from '@base-ui/react/use-render';
+import { ReactNode } from 'react';
+type StepperOrientation = "horizontal" | "vertical";
+type StepState = "active" | "completed" | "inactive" | "loading";
+type StepIndicators = Partial<Record<StepState, ReactNode>>;
+type StepperTriggerMode = "both" | "forward-only" | "backward-only" | "none";
+interface StepperContextValue {
+    activeStep: number;
+    setActiveStep: (step: number) => void;
+    orientation: StepperOrientation;
+    indicators: StepIndicators;
+    triggerMode: StepperTriggerMode;
+}
+declare function useStepper(): StepperContextValue;
+interface StepItemContextValue {
+    step: number;
+    state: StepState;
+    isDisabled: boolean;
+    isLoading: boolean;
+}
+declare function useStepItem(): StepItemContextValue;
+interface StepperRootProps extends useRender.ComponentProps<"div"> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: StepperOrientation;
+    indicators?: StepIndicators;
+    triggerMode?: StepperTriggerMode;
+}
+export declare function StepperRoot({ defaultValue, value, onValueChange, orientation, indicators, triggerMode, className, render, children, ...props }: StepperRootProps): import("react/jsx-runtime").JSX.Element;
+export declare function StepperNav({ className, render, children, ...props }: useRender.ComponentProps<"nav">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+interface StepperItemProps extends useRender.ComponentProps<"div"> {
+    step: number;
+    disabled?: boolean;
+    loading?: boolean;
+}
+export declare function StepperItem({ step, disabled, loading, className, render, children, ...props }: StepperItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function StepperTrigger({ className, render, children, ...props }: useRender.ComponentProps<"button">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function StepperIndicator({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function StepperSeparator({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function StepperTitle({ className, render, children, ...props }: useRender.ComponentProps<"h3">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function StepperDescription({ className, render, children, ...props }: useRender.ComponentProps<"p">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function StepperPanel({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+interface StepperContentProps extends useRender.ComponentProps<"div"> {
+    value: number;
+    forceMount?: boolean;
+}
+export declare function StepperContent({ value, forceMount, className, render, children, ...props }: StepperContentProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
+interface StepperItemData {
+    title?: ReactNode;
+    description?: ReactNode;
+    indicator?: ReactNode;
+    content?: ReactNode;
+    disabled?: boolean;
+    loading?: boolean;
+}
+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 Stepper({ items, classNames, ...props }: StepperProps): import("react/jsx-runtime").JSX.Element;
+export { useStepper, useStepItem };
+export type { StepperRootProps, StepperItemProps, StepperContentProps, StepperOrientation, StepperTriggerMode, StepState, StepIndicators, StepperItemData, StepperProps, };

package/dist/src/components/stepper/stepper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/switch/index.d.ts

@@ -0,0 +1 @@
+export * from './switch';

package/dist/src/components/switch/switch.d.ts

@@ -0,0 +1,21 @@
+import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
+import type * as React from "react";
+export declare function SwitchRoot({ className, ...props }: SwitchPrimitive.Root.Props): React.ReactElement;
+export declare function SwitchThumb({ className, ...props }: SwitchPrimitive.Thumb.Props): React.ReactElement;
+interface SwitchProps extends Omit<SwitchPrimitive.Root.Props, "children"> {
+    children?: React.ReactNode;
+    label?: React.ReactNode;
+    tooltip?: string;
+    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 Switch({ children, label, className, id, controlFirst, tooltip, classNames, ...props }: SwitchProps): React.ReactElement;
+export {};

package/dist/src/components/switch/switch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/table/index.d.ts

@@ -0,0 +1 @@
+export * from './table';

package/dist/src/components/table/table.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode } from 'react';
+import * as React from "react";
+export type ColumnDef<T> = {
+    header: string | (() => ReactNode);
+    key: keyof T;
+    cell?: (row: T, index: number) => ReactNode;
+    width?: string | number;
+};
+type TableRootProps = React.ComponentProps<"table"> & {
+    /** Styles applied to each internal slot. */
+    classNames?: {
+        /** Outer wrapper div with overflow handling. */
+        container?: string;
+    };
+};
+export declare function TableRoot({ className, classNames, ...props }: TableRootProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): import("react/jsx-runtime").JSX.Element;
+export declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): import("react/jsx-runtime").JSX.Element;
+export declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): import("react/jsx-runtime").JSX.Element;
+export declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+export declare function TableHead({ className, ...props }: React.ComponentProps<"th">): import("react/jsx-runtime").JSX.Element;
+export declare function TableCell({ className, ...props }: React.ComponentProps<"td">): import("react/jsx-runtime").JSX.Element;
+export declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): import("react/jsx-runtime").JSX.Element;
+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.ComponentProps<"table">, "onDoubleClick">;
+export declare function Table<T>({ data, columns, getRowKey, onRowClick, onRowDoubleClick, selected, classNames, ...tableProps }: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/table/table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/tabs/index.d.ts

@@ -0,0 +1 @@
+export * from './tabs';

package/dist/src/components/tabs/tabs.d.ts

@@ -0,0 +1,11 @@
+import { Tabs as TabsPrimitive } from '@base-ui/react/tabs';
+import { default as React } from 'react';
+export type TabsVariant = "underline" | "background";
+export declare function Tabs({ className, ...props }: TabsPrimitive.Root.Props): React.ReactElement;
+export declare function TabsList({ variant, centered, className, children, ...props }: TabsPrimitive.List.Props & {
+    variant?: TabsVariant;
+    centered?: boolean;
+}): React.ReactElement;
+export declare function TabsTab({ className, ...props }: TabsPrimitive.Tab.Props): React.ReactElement;
+export declare function TabsPanel({ className, ...props }: TabsPrimitive.Panel.Props): React.ReactElement;
+export { TabsPrimitive, TabsTab as TabsTrigger, TabsPanel as TabsContent, TabsList as TabList, };

package/dist/src/components/tabs/tabs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/tag/index.d.ts

@@ -0,0 +1 @@
+export * from './tag';

package/dist/src/components/tag/tag.d.ts

@@ -0,0 +1,7 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+declare const tagVariants: (props?: ({
+    variant?: "default" | "link" | "error" | "success" | "warning" | "outline" | "secondary" | "ghost" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Tag({ className, variant, render, ...props }: useRender.ComponentProps<"span"> & VariantProps<typeof tagVariants>): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export { Tag, tagVariants };

package/dist/src/components/tag/tag.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/textarea/index.d.ts

@@ -0,0 +1 @@
+export * from './textarea';

package/dist/src/components/textarea/textarea.d.ts

@@ -0,0 +1,5 @@
+import { ChangeEvent, ComponentProps, ReactElement } from 'react';
+export type TextareaProps = Omit<ComponentProps<"textarea">, "onChange"> & {
+    onValueChange?: (value: string, event: ChangeEvent<HTMLTextAreaElement>) => void;
+};
+export declare function Textarea({ className, onValueChange, ...props }: TextareaProps): ReactElement;

package/dist/src/components/textarea/textarea.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/timeline/index.d.ts

@@ -0,0 +1 @@
+export * from './timeline';

package/dist/src/components/timeline/timeline.d.ts

@@ -0,0 +1,50 @@
+import { useRender } from '@base-ui/react/use-render';
+import { ReactNode } from 'react';
+type TimelineOrientation = "horizontal" | "vertical";
+interface TimelineRootProps extends useRender.ComponentProps<"div"> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: TimelineOrientation;
+}
+export declare function TimelineRoot({ defaultValue, value, onValueChange, orientation, className, render, children, ...props }: TimelineRootProps): import("react/jsx-runtime").JSX.Element;
+interface TimelineItemProps extends useRender.ComponentProps<"div"> {
+    step: number;
+}
+export declare function TimelineItem({ step, className, render, children, ...props }: TimelineItemProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TimelineHeader({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TimelineTitle({ className, render, children, ...props }: useRender.ComponentProps<"h3">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TimelineDate({ className, render, children, ...props }: useRender.ComponentProps<"time">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TimelineContent({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TimelineIndicator({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TimelineSeparator({ className, render, children, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+type TimelineVariant = "default" | "alternate" | "date-left";
+interface TimelineItemData {
+    title?: ReactNode;
+    content?: ReactNode;
+    date?: ReactNode;
+    indicator?: ReactNode;
+}
+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;
+    };
+}
+export declare function Timeline({ items, variant, classNames, ...props }: TimelineProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/timeline/timeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/toast/index.d.ts

@@ -0,0 +1 @@
+export * from './toast';

package/dist/src/components/toast/toast.d.ts

@@ -0,0 +1,101 @@
+import { ToastManagerAddOptions as BaseToastManagerAddOptions, Toast, ToastObject } from '@base-ui/react/toast';
+import { ComponentProps, ReactNode } from 'react';
+import { Button } from '../button';
+export type ToastVariant = "default" | "success" | "error" | "warning" | "info";
+type ButtonProps = ComponentProps<typeof Button>;
+export declare function toastVariants({ variant, }?: {
+    variant?: ToastVariant;
+}): string;
+type ToastOptionsBase = {
+    variant?: ToastVariant;
+    content?: ReactNode;
+    actions?: ButtonProps[];
+    bump?: boolean;
+};
+export type ToastOptions<Data extends object = object> = ToastObject<Data> & ToastOptionsBase;
+export type ToastManagerAddOptions<Data extends object = object> = BaseToastManagerAddOptions<Data> & ToastOptionsBase;
+export declare function useToastManager(): {
+    toasts: ToastOptions<any>[];
+    add: (<T extends any = any>(options: BaseToastManagerAddOptions<T>) => string) & ((options: ToastManagerAddOptions<any>) => any);
+    close: ((toastId?: string) => void) & ((id?: string) => any);
+    update: (<T extends any = any>(toastId: string, options: import('@base-ui/react').ToastManagerUpdateOptions<T>) => void) & ((id: string, options: Partial<ToastManagerAddOptions<any>>) => any);
+    promise: (<Value, T extends any = any>(promise: Promise<Value>, options: import('@base-ui/react').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 createToastManager(): import('@base-ui/react').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;
+};
+type ToastArg = string | Omit<ToastManagerAddOptions<any>, "variant">;
+/**
+ * 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 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 Toast.createToastManager>;
+    /**
+     * Container element for the portal.
+     * @default document.body
+     */
+    container?: HTMLElement | null;
+}
+/**
+ * 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): import("react/jsx-runtime").JSX.Element;
+export { Toast as ToastPrimitive };

package/dist/src/components/toast/toast.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from './tooltip';

package/dist/src/components/tooltip/tooltip.d.ts

@@ -0,0 +1,52 @@
+import { Tooltip as TooltipBase } from '@base-ui/react/tooltip';
+import { ComponentPropsWithoutRef, ReactElement, ReactNode } from 'react';
+type RootProps = ComponentPropsWithoutRef<typeof TooltipBase.Root>;
+type TriggerProps = ComponentPropsWithoutRef<typeof TooltipBase.Trigger>;
+type PopupProps = ComponentPropsWithoutRef<typeof TooltipBase.Popup>;
+type ArrowProps = ComponentPropsWithoutRef<typeof TooltipBase.Arrow>;
+type ProviderProps = ComponentPropsWithoutRef<typeof TooltipBase.Provider>;
+/** Enables shared hover intent and delay grouping across multiple tooltips. */
+export declare function TooltipProvider(props: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipRoot(props: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipTrigger({ className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipPopup({ className, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipArrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export 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 (visual root). */
+    className?: 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;
+    };
+};
+/**
+ * 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, classNames, ...triggerProps }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export { TooltipBase as TooltipPrimitive };

package/dist/src/components/tooltip/tooltip.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/tree/index.d.ts

@@ -0,0 +1 @@
+export * from './tree';

package/dist/src/components/tree/tree.d.ts

@@ -0,0 +1,18 @@
+import { useRender } from '@base-ui/react/use-render';
+import { ItemInstance, TreeInstance } from '@headless-tree/core';
+import { ReactNode } from 'react';
+interface TreeRootProps<T> extends useRender.ComponentProps<"div"> {
+    tree: TreeInstance<T>;
+    indent?: number;
+}
+export declare function TreeRoot<T>({ tree, indent, className, render, style, ...props }: TreeRootProps<T>): import("react/jsx-runtime").JSX.Element;
+type ParentIcon = ReactNode | ((isExpanded: boolean) => ReactNode);
+interface TreeItemProps<T> extends useRender.ComponentProps<"button"> {
+    item: ItemInstance<T>;
+    leafIcon?: ReactNode;
+    parentIcon?: ParentIcon;
+}
+export declare function TreeItem<T>({ item, leafIcon, parentIcon, className, render, children, style, ...props }: TreeItemProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function TreeItemLabel({ className, render, children, ...props }: useRender.ComponentProps<"span">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function TreeDragLine({ className, render, style, ...props }: useRender.ComponentProps<"div">): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
+export type { TreeRootProps, TreeItemProps };

package/dist/src/components/tree/tree.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,27 @@
+export { useControllableState } from '@radix-ui/react-use-controllable-state';
+export * from './use-array';
+export * from './use-async';
+export * from './use-boolean';
+export * from './use-click-outside';
+export * from './use-clipboard';
+export * from './use-debounce-callback';
+export * from './use-debounce-value';
+export * from './use-disclosure';
+export * from './use-document-title';
+export * from './use-event-listener';
+export * from './use-focus-trap';
+export * from './use-hotkey';
+export * from './use-hover';
+export * from './use-is-visible';
+export * from './use-local-storage';
+export * from './use-media-query';
+export * from './use-memoized-fn';
+export * from './use-mutation';
+export * from './use-object';
+export * from './use-on-mount';
+export * from './use-pagination';
+export * from './use-portal';
+export * from './use-prevent-page-close';
+export * from './use-range-pagination';
+export * from './use-selection';
+export * from './use-step';

package/dist/src/hooks/internal/index.d.ts

@@ -0,0 +1,4 @@
+export { isAppleDevice } from './is-apple-device';
+export { isBrowser } from './is-browser';
+export { useIsomorphicLayoutEffect } from './use-isomorphic-layout-effect';
+export { useLatestRef } from './use-latest-ref';

package/dist/src/hooks/internal/is-apple-device.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lazily detects whether the current device is an Apple platform (macOS, iOS,
+ * iPadOS). Reads `navigator.userAgentData?.platform` when available, falling
+ * back to the legacy `navigator.platform`.
+ *
+ * SSR-safe: returns `false` when there is no `navigator` (e.g. on the server),
+ * so the `mod` hotkey modifier deterministically resolves to `ctrl` there.
+ *
+ * The check runs on every call (not memoized at module-eval) so it can be
+ * stubbed per-test and stays correct if the environment changes.
+ */
+export declare const isAppleDevice: () => boolean;