@boxcustodia/library 0.5.5 → 0.6.1-canary.1

package/dist/index.d.ts

@@ -0,0 +1,1880 @@
+import { ButtonHTMLAttributes } from 'react';
+import { ClassNameValue } from 'tailwind-merge';
+import { ClassProp } from 'class-variance-authority/types';
+import { ClassValue } from 'clsx';
+import { Collection } from 'react-aria-components';
+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 { 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 { FormEvent } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLProps } from 'react';
+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 { PopoverAnchor } from '@radix-ui/react-popover';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { Presence } from '@radix-ui/react-presence';
+import * as React_2 from 'react';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { RefAttributes } from 'react';
+import { RefObject } from 'react';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { SetStateAction } from 'react';
+import { Slot } from '@radix-ui/react-slot';
+import { SlotProps } from '@radix-ui/react-slot';
+import { StoreApi } from 'zustand';
+import { TreeItemProps } from 'react-aria-components';
+import { TreeProps } from 'react-aria-components';
+import { UNSTABLE_TreeItemContent } 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 { VariantProps } from 'class-variance-authority';
+import { ZodType } from 'zod';
+
+export declare const AlertDialog: {
+    ({ title, description, trigger, onClose, onAction, variant, triggerProps, contentProps, headerProps, titleProps, descriptionProps, footerProps, closeProps, closeText, actionText, actionProps, ...props }: AlertDialogProps): JSX.Element;
+    displayName: string;
+};
+
+declare type AlertDialogProps = React.ComponentPropsWithoutRef<typeof DialogRoot> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    trigger?: React.ReactNode;
+    onClose?: () => void;
+    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;
+};
+
+export declare type ArrayUnion<V, T extends ReadonlyArray<V>> = T[number];
+
+declare interface AsyncState<T> {
+    loading: boolean;
+    error: Error | null;
+    data: T | null;
+    refetch: () => void;
+}
+
+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;
+    displayName: string;
+};
+
+export declare const AutoCompleteDialog: ({ children, ...props }: AutoCompleteDialogProps) => JSX.Element;
+
+declare interface AutoCompleteDialogProps extends DialogProps {
+}
+
+export declare const AutoCompleteEmpty: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AutoCompleteGroup: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React_2.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AutoCompleteInput: React_2.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React_2.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React_2.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React_2.RefAttributes<HTMLInputElement>, "ref"> & React_2.RefAttributes<HTMLInputElement>>;
+
+export declare const AutoCompleteItem: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AutoCompleteList: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AutoCompleteRoot: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AutoCompleteSeparator: React_2.ForwardRefExoticComponent<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const AutoCompleteShortcut: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const Avatar: ({ variant, size, fallback, alt, src, className, imageProps, ...props }: AvatarProps) => JSX.Element;
+
+declare type AvatarProps = OverrideProps<HTMLProps<HTMLDivElement>, VariantProps<typeof avatarVariants> & {
+    fallback?: ReactNode;
+    alt: string;
+    src: string;
+    imageProps?: HTMLProps<HTMLImageElement>;
+}>;
+
+declare const avatarVariants: (props?: ({
+    variant?: "circle" | "square" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const BackgroundImage: ForwardRefExoticComponent<Omit<Props_4, "ref"> & RefAttributes<HTMLDivElement>>;
+
+export declare const BaseButton: ForwardRefExoticComponent<Props_2 & RefAttributes<HTMLButtonElement>>;
+
+declare type BaseButtonProps = ComponentProps<typeof BaseButton>;
+
+export declare type BaseEntity = {
+    id: string;
+    createdAt: Date;
+};
+
+declare type BaseProps = {
+    icon?: React.ReactNode;
+    rounded?: TagVariant["rounded"];
+} & StyleProps & React.HTMLAttributes<HTMLDivElement>;
+
+export declare const Button: ForwardRefExoticComponent<Omit<Props, "ref"> & RefAttributes<HTMLButtonElement>>;
+
+declare type ButtonProps = ComponentProps<typeof Button>;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "error" | "success" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const Calendar: {
+    <T extends Mode>(props: CalendarProps<T>): JSX.Element;
+    displayName: string;
+};
+
+export declare type CalendarBaseProps<T extends Mode> = {
+    disabled?: (date: Date) => boolean;
+    mode: T;
+};
+
+export declare type CalendarModeProps<T extends Mode> = CalendarBaseProps<T> & {
+    single: SingleDateValue;
+    range: RangeDateValue;
+    multiple: MultipleDateValue;
+}[T];
+
+declare interface CalendarNavigationProps {
+    view: CalendarView;
+    setView: (view: CalendarView) => void;
+    value: Date;
+    previousMonth: () => void;
+    nextMonth: () => void;
+    previousYear: () => void;
+    nextYear: () => void;
+    previousDecade: () => void;
+    nextDecade: () => void;
+    goBackProps?: Omit<ButtonProps, "onClick">;
+    goNextProps?: Omit<ButtonProps, "onClick">;
+    changeViewProps?: Omit<HTMLProps<HTMLButtonElement>, "onClick">;
+}
+
+declare type CalendarProps<T extends Mode> = CalendarModeProps<T> & NavigationProps & {
+    initialView?: CalendarView;
+    initialDate?: Date;
+    monthViewProps?: Omit<MonthViewProps, "navigationDate">;
+    className?: ClassName;
+};
+
+declare type CalendarProps_2<T extends Mode> = ComponentProps<typeof Calendar<T>>;
+
+export declare type CalendarState = {
+    defaultStartDate: Date;
+    mode: Mode;
+    isSingleMode: boolean;
+    isRangeMode: boolean;
+    selected: DateMatcher;
+    selectDate: (date: Date) => void;
+    isSelected: (day: Date) => boolean;
+    isInRange: (day: Date) => boolean;
+    isFirstDayFromRange: (day: Date) => boolean;
+    isLastDayFromRange: (day: Date) => boolean;
+};
+
+export declare type CalendarView = "month" | "year" | "decade";
+
+export declare const Card: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardContent: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardDescription: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLParagraphElement> & default_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare const CardFooter: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardHeader: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLDivElement> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CardTitle: default_2.ForwardRefExoticComponent<default_2.HTMLAttributes<HTMLHeadingElement> & default_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare type CellProps<T> = {
+    row: T;
+};
+
+export declare const Center: ({ className, ...props }: ComponentPropsWithoutRef<"div">) => JSX.Element;
+
+export declare const Checkbox: {
+    ({ checked, onChange, defaultChecked, className, size, children, containerClassName, containerProps, ...props }: Props_5): JSX.Element;
+    displayName: string;
+};
+
+export declare type ClassName = string | undefined;
+
+export declare const click: (element: HTMLElement) => void;
+
+export declare type ClickEvent = React.MouseEvent<HTMLButtonElement, MouseEvent>;
+
+declare type ClosableProps = BaseProps & {
+    closable: true;
+    onClose: () => void;
+};
+
+export declare function cn(...args: ClassValue[]): string;
+
+export { Collection }
+
+declare type ColorProps = {
+    color: string;
+    variant?: "outline" | "borderless";
+};
+
+export declare type ColumnDef<T> = {
+    /**
+     * Header de la columna
+     */
+    header: string | (() => ReactNode);
+    /**
+     * Clave que identifica la columna
+     */
+    key: keyof T;
+    /**
+     * Elemento que se renderiza en la celda
+     */
+    cell?: (props: CellProps<T>) => ReactNode;
+    /**
+     * Ancho de la columna
+     */
+    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;
+
+declare type ContainerProps = React_2.ComponentPropsWithoutRef<"div">;
+
+export declare type Controllable<C, T extends NonNullable<unknown>> = OverrideProps<HTMLProps<C>, ControllableState<T>>;
+
+export declare type ControllableState<T> = {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (state: T) => void;
+};
+
+declare type CopiedValue = string | null;
+
+declare type CopyFunction = (text: string) => Promise<boolean>;
+
+export declare const createSafeContext: <T>() => readonly [() => T & ({} | undefined), default_2.Provider<T | null>];
+
+export declare type DateMatcher = DateSingle | DateRange | DateMultiple;
+
+export declare type DateMultiple = Date[];
+
+export declare const DatePicker: <T extends Mode = "single">(props: Props_8<T>) => JSX.Element;
+
+export declare type DatePickerFooterProps<T extends Mode> = {
+    mode: Mode;
+    value: CalendarProps_2<T>["value"];
+    clear: () => void;
+    selectToday: () => void;
+    setValue: (value: CalendarProps_2<T>["value"]) => void;
+};
+
+export declare type DateRange = {
+    start: DateSingle;
+    end: DateSingle;
+};
+
+export declare type DateSingle = Date | null;
+
+declare type DayProps = {
+    day: Date;
+    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;
+
+export declare const DialogClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const DialogContent: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    focus?: boolean;
+    hideClose?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DialogDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare const DialogFooter: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const DialogHeader: {
+    ({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};
+
+export declare const DialogOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const DialogPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;
+
+export declare const DialogRoot: React_2.FC<DialogPrimitive.DialogProps>;
+
+export declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+
+export declare const DialogTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const Divider: (props: Props_10) => JSX.Element;
+
+export declare const DOTS = "...";
+
+export declare const Dropzone: ({ onFileAdd, onFileRemove, onChangeFiles, files, maxFiles, allowedExtensions, maxFileSize, multiple, renderAcceptedFile, renderRejectedFile, showRejected, className, icon: Icon, iconSize, ...props }: DropzoneProps) => JSX.Element;
+
+export declare type DropzoneProps = {
+    /**
+     * Función que se ejecuta cuando se agregan archivos
+     */
+    onFileAdd?: (files: File[]) => void;
+    /**
+     * Función que se ejecuta cuando se elimina un archivo
+     */
+    onFileRemove?: (index: number, type: "accepted" | "rejected") => void;
+    /**
+     * Evento que captura cambios en lista de archivos
+     * @default () => {}
+     */
+    onChangeFiles?: (files: File[]) => void;
+    /**
+     * Lista de archivos
+     * @default []
+     */
+    files?: File[];
+    /**
+     * Número máximo de archivos permitidos
+     * @default 1
+     */
+    maxFiles?: number;
+    /**
+     * Lista de extensiones permitidas (e.j. ["image/jpeg", "image/png"])
+     * @default []
+     */
+    allowedExtensions?: FileTypeValue[];
+    /**
+     * Tamaño máximo de archivo en bytes
+     * @default 5MB
+     */
+    maxFileSize?: number;
+    /**
+     * Permite seleccionar múltiples archivos
+     */
+    multiple?: boolean;
+    /**
+     * Función para renderizar cada archivo aceptado
+     */
+    renderAcceptedFile?: (file: File, removeItem: () => void) => React.ReactNode;
+    /**
+     * Función para renderizar cada archivo rechazado
+     */
+    renderRejectedFile?: (file: File, removeItem: () => void) => React.ReactNode;
+    /**
+     * Mostrar archivos rechazados
+     * @default false
+     */
+    showRejected?: boolean;
+    /**
+     * Clase CSS para el contenedor
+     */
+    className?: string;
+    /**
+     * Icono personalizado para el dropzone
+     * @default UploadCloud
+     */
+    icon?: LucideIcon;
+    /**
+     * Tamaño del icono
+     * @default 40
+     */
+    iconSize?: number;
+} & Omit<ComponentPropsWithoutRef<"div">, "onDrop">;
+
+export declare const EmptyState: {
+    ({ icon, title, description, className, children, ...props }: Props_11): JSX.Element;
+    displayName: string;
+};
+
+export declare const ensureReactElement: <P>({ children, as: Wrapper, props, }: EnsureReactElementProps<P>) => ReactElement;
+
+declare type EnsureReactElementProps<P = {}> = {
+    children: Renderable<P>;
+    as?: default_2.ElementType;
+    props?: P;
+};
+
+export declare type Entity<T> = {
+    [K in keyof T]: T[K];
+} & BaseEntity;
+
+declare interface ExtendedProps {
+    containerClassName: ClassName;
+    inputClassName: ClassName;
+    listClassName: ClassName;
+    itemClassName: ClassName;
+    emptyClassName: ClassName;
+    containerProps: ComponentProps<typeof AutoCompleteRoot>;
+    inputProps: ComponentProps<typeof AutoCompleteInput>;
+    listProps: ComponentProps<typeof AutoCompleteList>;
+    itemProps: ComponentProps<typeof AutoCompleteItem>;
+    emptyProps: ComponentProps<typeof AutoCompleteEmpty>;
+}
+
+declare interface ExtendedProps_2 {
+    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;
+    tbodyProps?: HTMLProps<HTMLTableSectionElement>;
+    trClassName?: ClassName;
+    trProps?: HTMLProps<HTMLTableRowElement>;
+    thClassName?: ClassName;
+    thProps?: HTMLProps<HTMLTableCellElement>;
+    tdClassName?: ClassName;
+    tdProps?: HTMLProps<HTMLTableCellElement>;
+}
+
+/**
+ * Extracts the initials from a string.
+ * @param {string} string - The input string.
+ * @returns {string} The initials extracted from the input string.
+ */
+export declare const extractInitials: (string: string) => string;
+
+export declare const Field: ForwardRefExoticComponent<Props_12 & RefAttributes<HTMLDivElement>>;
+
+export declare const FileType: {
+    readonly JPEG: "image/jpeg";
+    readonly JPG: "image/jpg";
+    readonly PNG: "image/png";
+    readonly GIF: "image/gif";
+    readonly WEBP: "image/webp";
+    readonly SVG: "image/svg+xml";
+    readonly PDF: "application/pdf";
+    readonly DOC: "application/msword";
+    readonly DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    readonly XLS: "application/vnd.ms-excel";
+    readonly XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    readonly PPT: "application/vnd.ms-powerpoint";
+    readonly PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    readonly TXT: "text/plain";
+    readonly CSV: "text/csv";
+    readonly ZIP: "application/zip";
+    readonly RAR: "application/x-rar-compressed";
+    readonly MP3: "audio/mpeg";
+    readonly WAV: "audio/wav";
+    readonly MP4: "video/mp4";
+    readonly WEBM: "video/webm";
+    readonly JSON: "application/json";
+    readonly XML: "application/xml";
+};
+
+export declare const FileTypeGroups: Record<string, FileTypeValue[]>;
+
+export declare type FileTypeValue = (typeof FileType)[keyof typeof FileType];
+
+export declare const Form: <TFieldValues extends FieldValues>({ onSubmit, id, form, children, className, }: Props_13<TFieldValues>) => JSX.Element;
+
+export declare const FormControl: React_2.ForwardRefExoticComponent<Omit<SlotProps & React_2.RefAttributes<HTMLElement>, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+export declare const FormDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, label, description, 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;
+    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: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const FormLabel: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & React_2.RefAttributes<HTMLLabelElement>>;
+
+export declare const FormMessage: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;
+
+export declare interface GenericMenuProps {
+    trigger: default_2.ReactNode;
+    items: MenuItemType[];
+    side?: "top" | "right" | "bottom" | "left";
+    offset?: ComponentPropsWithoutRef<typeof MenuContent>["sideOffset"];
+    contentProps?: ComponentPropsWithoutRef<typeof MenuContent>;
+}
+
+export declare type GenericObject<T = any> = {
+    [key: string]: T;
+};
+
+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;
+    displayName: string;
+};
+
+declare const HeadingVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | null | undefined;
+    weight?: "bold" | "normal" | "medium" | "semibold" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare type HotkeyEventName = "keydown" | "keypress" | "keyup";
+
+declare type HotkeyOptions = {
+    watch?: boolean;
+    eventName?: HotkeyEventName;
+    preventDefault?: boolean;
+    ignoreInputFields?: boolean;
+};
+
+export declare type ID = string | number;
+
+export declare const Input: ForwardRefExoticComponent<Omit<Props_15, "ref"> & RefAttributes<HTMLInputElement>>;
+
+declare interface ItemTimeline {
+    content?: ReactNode;
+    icon?: ReactNode;
+    status?: "done" | "pending" | "error";
+    color?: string;
+}
+
+export declare interface IToast {
+    id: number | string;
+    title?: string;
+    description: ReactNode;
+    type: ToastType;
+}
+
+export declare const Kbd: {
+    ({ variant, size, className, ...props }: Props_16): JSX.Element;
+    displayName: string;
+};
+
+declare const KbdVariants: (props?: ({
+    variant?: "default" | "error" | "outline" | "secondary" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare type Keys = string | string[];
+
+export declare const Label: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & React_2.RefAttributes<HTMLLabelElement>>;
+
+export declare const Loader: {
+    ({ center, containerClassName, variant, size, ...props }: Props_17): JSX.Element;
+    displayName: string;
+};
+
+declare type LoaderVariants = VariantProps<typeof loaderVariants>;
+
+declare const loaderVariants: (props?: ({
+    variant?: "error" | "success" | "secondary" | "ghost" | "primary" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare type Loose<T> = T | (string & {});
+
+export declare type Maybe<T> = T | undefined | null;
+
+export declare type MaybeRef<T> = T | MutableRefObject<T>;
+
+declare type MaybeReturn<TState> = Return<TState | undefined, ((state: TState | undefined) => Partial<TState>) | Partial<TState>>;
+
+export declare const Menu: {
+    ({ trigger, items, contentProps, side, offset, }: GenericMenuProps): JSX.Element;
+    displayName: string;
+};
+
+export declare const MenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+declare type MenuItemBase<T extends ElementType> = ComponentPropsWithoutRef<T> & {
+    label?: ReactNode;
+    type: string;
+} & Shortcut;
+
+declare type MenuItemCheckbox = MenuItemBase<typeof MenuCheckboxItem> & {
+    type: "checkbox";
+};
+
+declare type MenuItemItem = MenuItemBase<typeof MenuItem> & {
+    type: "item";
+};
+
+declare type MenuItemLabel = MenuItemBase<typeof MenuLabel> & {
+    type: "label";
+};
+
+declare type MenuItemRadio = MenuItemBase<typeof MenuRadioItem> & {
+    type: "radio";
+};
+
+declare type MenuItemSeparator = MenuItemBase<typeof MenuSeparator> & {
+    type: "separator";
+};
+
+declare type MenuItemSubmenu = MenuItemBase<typeof MenuSubTrigger> & {
+    type: "submenu";
+    items: MenuItemType[];
+};
+
+export declare type MenuItemType = MenuItemItem | MenuItemCheckbox | MenuItemRadio | MenuItemLabel | MenuItemSeparator | MenuItemSubmenu;
+
+export declare const MenuLabel: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuPortal: React_2.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+
+export declare const MenuRadioGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuRadioItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuRoot: React_2.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+
+export declare const MenuSeparator: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuShortcut: {
+    ({ className, keys, handler, options, ...props }: MenuShortcutProps): JSX.Element;
+    displayName: string;
+};
+
+declare type MenuShortcutProps = React_2.ComponentPropsWithoutRef<"span"> & {
+    keys: Keys;
+    handler: (event: KeyboardEvent) => any;
+    options?: HotkeyOptions;
+};
+
+declare type MenuShortcutProps_2 = ComponentPropsWithoutRef<typeof MenuShortcut>;
+
+export declare const MenuSub: React_2.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+
+export declare const MenuSubContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuSubTrigger: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const MenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare function mergeRefs<T = any>(refs: Array<React_2.MutableRefObject<T> | React_2.LegacyRef<T> | undefined | null>): React_2.RefCallback<T>;
+
+export declare type Mode = "single" | "range" | "multiple";
+
+export declare const monthNames: readonly ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"];
+
+declare type MonthViewProps = {
+    navigationDate: Date;
+    disabled?: (date: Date) => boolean;
+    dayClassName?: ClassName;
+    dayProps?: DayProps;
+    weekDaysClassName?: ClassName;
+    weekDaysProps?: WeekDaysProps;
+};
+
+export declare type MultipleDateValue = {
+    value?: Date[];
+    defaultValue?: Date[];
+    onChange?: (dates: Date[]) => void;
+};
+
+export declare const MultiSelect: {
+    <TItem extends Record<string, any> = Option_2<string>>({ items, value, valueKey, labelKey, onChange, variant, defaultValue, placeholder, maxCount, className, renderOption, withCheckbox, showSearch, showSelectAll, ...props }: MultiSelectProps<TItem>): JSX.Element;
+    displayName: string;
+};
+
+declare type MultiSelectProps<TItem extends Record<string, any>> = OverrideProps<React_2.ButtonHTMLAttributes<HTMLButtonElement> & OpenProps & VariantProps<typeof multiSelectVariants>, {
+    items: TItem[];
+    /**
+     * Identificador del valor del elemento
+     * @default "value"
+     */
+    valueKey?: keyof TItem;
+    /**
+     * Identificador del label del elemento
+     * @default "label"
+     */
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    defaultValue?: string[];
+    labelKey?: keyof TItem;
+    placeholder?: string;
+    /**
+     * Cantidad máxima de elementos que se van a visualizar
+     * @default 3
+     */
+    maxCount?: number;
+    className?: string;
+    renderOption?: (item: TItem) => React_2.ReactNode;
+    withCheckbox?: boolean;
+    /**
+     * Para mostrar o no la barra de búsqueda
+     * @default true
+     */
+    showSearch?: boolean;
+    /**
+     * Para mostrar o no el "Seleccionar todos"
+     * @default true
+     */
+    showSelectAll?: boolean;
+}>;
+
+declare const multiSelectVariants: (props?: ({
+    variant?: "default" | "error" | "secondary" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare type Mutation<TArgs extends any[], TReturn> = (...args: TArgs) => Promise<TReturn>;
+
+declare type NavigationProps = Pick<CalendarNavigationProps, "goNextProps" | "goBackProps" | "changeViewProps">;
+
+declare type NonClosableProps = BaseProps & {
+    closable?: false;
+    onClose?: never;
+};
+
+declare type noop = (this: any, ...args: any[]) => any;
+
+export declare type Nullable<T> = T | null;
+
+export declare const NumberInput: ForwardRefExoticComponent<Omit<Props_18, "ref"> & RefAttributes<HTMLInputElement>>;
+
+declare type OpenProps = {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+};
+
+declare interface Option_2<TValue = string> {
+    label: string;
+    value: TValue;
+    disabled?: boolean;
+}
+export { Option_2 as Option }
+
+export declare type OverrideProps<T, TOverridden> = Omit<T, keyof TOverridden> & TOverridden;
+
+export declare type PageSize = (typeof TABLE_PAGE_SIZES)[number];
+
+export declare const Pagination: {
+    ({ optionProps, className, containerProps, ...rangeProps }: Props_19): JSX.Element;
+    displayName: string;
+};
+
+declare interface PaginationOptionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    isActive?: boolean;
+}
+
+export declare const Popover: {
+    ({ trigger, children, rootProps, triggerProps, contentProps, triggerAsChild, matchTriggerWidth, triggerClassName, contentClassName, side, offset, }: Props_20): JSX.Element;
+    displayName: string;
+};
+
+export declare const PopoverContent: React_2.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    matchTriggerWidth?: boolean;
+    focus?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const PopoverRoot: React_2.FC<PopoverPrimitive.PopoverProps>;
+
+export declare const PopoverTrigger: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare type Props = BaseButtonProps & VariantProps<typeof buttonVariants>;
+
+declare type Props_10 = {
+    orientation?: "horizontal" | "vertical";
+} & HTMLProps<HTMLHRElement>;
+
+declare type Props_11 = ComponentPropsWithoutRef<"div"> & {
+    icon?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+};
+
+declare interface Props_12 extends ComponentPropsWithoutRef<"div"> {
+    label?: ReactNode;
+    labelClassName?: string;
+    labelProps?: ComponentPropsWithoutRef<"label">;
+    error?: ReactNode;
+    errorClassName?: string;
+    errorProps?: ComponentPropsWithoutRef<"p">;
+}
+
+declare type Props_13<TFieldValues extends FieldValues> = {
+    onSubmit: (data: TFieldValues) => void;
+    form: UseFormReturn<TFieldValues>;
+    children: React_2.ReactNode;
+    className?: string;
+    id?: string;
+};
+
+declare type Props_14<C extends React.ElementType> = VariantProps<typeof HeadingVariants> & {
+    as?: C;
+} & Omit<React.ComponentPropsWithoutRef<C>, "as">;
+
+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 type Props_16 = ComponentPropsWithoutRef<"kbd"> & VariantProps<typeof KbdVariants>;
+
+declare type Props_17 = LucideProps & LoaderVariants & {
+    center?: boolean;
+    containerClassName?: string;
+};
+
+declare type Props_18 = OverrideProps<ComponentProps<"input">, {
+    /** valor del input */
+    value?: number;
+    /** functión a ejecutar cuando el valor cambia */
+    onChange?: (value: number) => void;
+    /** valor por defecto del input */
+    defaultValue?: number;
+    /** valor mínimo del input */
+    min?: number;
+    /** valor máximo del input */
+    max?: number;
+}>;
+
+declare interface Props_19 extends useRangePaginationProps {
+    optionProps?: PaginationOptionProps;
+    className?: string;
+    containerProps?: HTMLProps<HTMLDivElement>;
+}
+
+declare interface Props_2 extends ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+    loading?: boolean;
+    showLoader?: boolean;
+}
+
+declare interface Props_20 {
+    trigger?: ReactNode;
+    children: ReactNode;
+    rootProps?: ComponentPropsWithoutRef<typeof PopoverRoot>;
+    triggerProps?: ComponentPropsWithoutRef<typeof PopoverTrigger>;
+    triggerClassName?: ClassName;
+    contentProps?: ComponentPropsWithoutRef<typeof PopoverContent>;
+    contentClassName?: ClassName;
+    matchTriggerWidth?: ComponentPropsWithoutRef<typeof PopoverContent>["matchTriggerWidth"];
+    triggerAsChild?: ComponentPropsWithoutRef<typeof PopoverTrigger>["asChild"];
+    side?: "left" | "right" | "top" | "bottom";
+    offset?: ComponentPropsWithoutRef<typeof PopoverContent>["sideOffset"];
+}
+
+declare interface Props_21 extends ComponentPropsWithoutRef<typeof Slot> {
+    /** Si el componente está presente o no */
+    when: ComponentProps<typeof Presence>["present"];
+}
+
+declare interface Props_22 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_23 = OverrideProps<ComponentProps<"input">, {
+    checked?: boolean;
+    onChange?: (value: boolean) => void;
+    defaultChecked?: boolean;
+    containerClassName?: string;
+    containerProps?: Omit<ComponentProps<"div">, "className">;
+}>;
+
+declare type Props_24<T> = {
+    data: T[];
+    columns: ColumnDef<T>[];
+    onRowClick?: (row: T) => void;
+    selected?: (row: T) => boolean;
+} & ExtendedProps_3 & Omit<ComponentPropsWithoutRef<typeof TableRoot>, "data" | "selected">;
+
+declare type Props_25 = {
+    setPageSize?: (value: PageSize) => void;
+    pageSize?: PageSize;
+} & Omit<usePaginationProps, "pageSize"> & TablePaginationExtendedProps;
+
+declare type Props_26 = ClosableProps | NonClosableProps;
+
+declare type Props_27 = {
+    titleClassName?: ClassName;
+    titleProps?: HTMLProps<HTMLHeadingElement>;
+    descriptionClassName?: ClassName;
+    descriptionProps?: HTMLProps<HTMLParagraphElement>;
+    iconClassName?: ClassName;
+} & Omit_2<HTMLProps<HTMLDivElement>, "id"> & Omit_2<IToast, "id">;
+
+declare type Props_28 = ComponentProps<typeof PopoverAnchor> & {
+    /**
+     * 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 PopoverContent>["sideOffset"];
+};
+
+declare type Props_29<T extends TreeNode> = TreeRootProps & {
+    items: T[];
+};
+
+declare interface Props_3 extends ExtendedProps {
+    items: AutoCompleteItem[];
+    placeholder?: string;
+    emptyMessage?: string;
+    onSelect?: (value: AutoCompleteItem["value"], item: AutoCompleteItem) => any;
+}
+
+declare interface Props_30<T> extends UseAsyncOptions<T> {
+    fn: () => Promise<T>;
+    dependencies?: DependencyList;
+}
+
+declare interface Props_4 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;
+    size?: string | number;
+    containerClassName?: string;
+    containerProps?: Omit<ComponentProps<"div">, "className">;
+}>;
+
+declare type Props_6<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">, {
+    onChange?: (value: string, item: TItem) => void;
+    /**
+     * Listado de elementos a mostrar
+     * @default []
+     */
+    items: TItem[];
+    /**
+     * Identificador del valor del elemento
+     * @default "value"
+     */
+    valueKey?: keyof TItem;
+    /**
+     * Identificador del label del elemento
+     * @default "label"
+     */
+    labelKey?: keyof TItem;
+    /**
+     * Función que renderiza el label del elemento
+     * Por defecto renderiza el label del elemento
+     */
+    renderOption?: (item: TItem) => ReactNode;
+    className?: ClassName;
+    triggerProps?: ComponentProps<typeof SelectTrigger>;
+    contentClassName?: ClassName;
+    contentProps?: ComponentProps<typeof SelectContent>;
+    itemClassName?: ClassName;
+    itemProps?: ComponentProps<typeof SelectItem>;
+    placeholder?: string;
+}>;
+
+declare type Props_8<T extends Mode> = ComponentProps<"input"> & {
+    mode?: T;
+    disabledDate?: (date: Date) => boolean;
+    hideFooter?: boolean;
+    renderFooter?: (props: DatePickerFooterProps<T>) => ReactNode;
+} & Omit<CalendarProps_2<T>, "disabled" | "mode">;
+
+declare type Props_9 = ComponentPropsWithoutRef<typeof DialogRoot> & ExtendedProps_2 & {
+    trigger?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    children: ReactNode;
+    footer?: ReactNode;
+    focus?: boolean;
+};
+
+export declare type RangeDateValue = {
+    value?: DateRange;
+    defaultValue?: DateRange;
+    onChange?: (date: DateRange) => void;
+};
+
+export declare type Renderable<T> = ReactNode | ((props: T) => ReactElement);
+
+declare type Return<TState, TArgs = ((state: TState) => Partial<TState>) | Partial<TState>> = [TState, (arg: TArgs) => void, () => void];
+
+declare type Return_2<T> = {
+    /**
+     * Indica si todos los elementos están seleccionados.
+     */
+    isAllSelected: boolean;
+    /**
+     * Indica si ningun elemento está seleccionado.
+     */
+    isNoneSelected: boolean;
+    /**
+     * Función que devuelve true si el elemento dado está seleccionado, false de lo contrario.
+     * @param item El elemento a verificar.
+     * @returns true si el elemento está seleccionado, false de lo contrario.
+     */
+    isSelected: (item: T) => boolean;
+    /**
+     * Array de elementos seleccionados.
+     */
+    selected: T[];
+    /**
+     * Establece los elementos seleccionados.
+     * @param items Los elementos seleccionados.
+     */
+    setSelected: (items: T[]) => void;
+    /**
+     * Selecciona un elemento.
+     * @param item El elemento a seleccionar.
+     */
+    select: (item: T) => void;
+    /**
+     * Deselecciona un elemento.
+     * @param item El elemento a deseleccionar.
+     */
+    unselect: (item: T) => void;
+    /**
+     * Alterna la selección de un elemento (si está seleccionado, lo deselecciona y viceversa).
+     * @param item El elemento cuya selección se alternará.
+     */
+    toggle: (item: T) => void;
+    /**
+     * Alterna la selección de todos los elementos (si todos están seleccionados, los deselecciona; de lo contrario, los selecciona).
+     */
+    toggleAll: () => void;
+    /**
+     * Deselecciona todos los elementos.
+     */
+    clear: () => void;
+};
+
+declare interface Return_3<T = ReactNode> {
+    currentStepIndex: number;
+    step: T;
+    steps: T[];
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    goTo: (i: number) => void;
+    next: () => void;
+    back: () => void;
+    findAndGo: (callback: ListIterateeCustom<T, boolean>) => void;
+}
+
+declare type Return_4 = [boolean, (newValue?: boolean) => void];
+
+export declare type SafeOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+declare interface SearchProps {
+    search?: string;
+    searchDefaultValue?: string;
+    onSearchChange?: (search: string) => void;
+    searchProps?: ComponentProps<typeof AutoCompleteInput>;
+    searchPlaceholder?: string;
+}
+
+export declare const Select: {
+    <TItem extends Record<string, any> = Option_2<string>>({ items, valueKey, labelKey, value: prop, onChange, defaultValue: defaultProp, renderOption, triggerProps, contentClassName, contentProps, itemClassName, itemProps, className, placeholder, ...props }: Props_7<TItem>): JSX.Element;
+    displayName: string;
+};
+
+export declare const SelectContent: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectGroup: React_2.FC<SelectGroupProps>;
+
+declare interface SelectGroupProps extends React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Group> {
+    heading?: string;
+}
+
+export declare const SelectItem: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectLabel: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+declare type SelectProps<TItem extends Record<string, any>> = ComponentProps<typeof Select<TItem>>;
+
+export declare const SelectRoot: React_2.FC<SelectPrimitive.SelectProps>;
+
+export declare const SelectScrollDownButton: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectScrollUpButton: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectSeparator: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const SelectTrigger: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare type SetState<T> = Dispatch<SetStateAction<T>>;
+
+declare type Shortcut = Partial<{
+    shortcut: MenuShortcutProps_2["keys"];
+    onShortcut: MenuShortcutProps_2["handler"];
+    shortcutOptions: MenuShortcutProps_2["options"];
+}>;
+
+export declare const Show: {
+    (props: Props_21): JSX.Element;
+    displayName: string;
+};
+
+export declare type SingleDateValue = {
+    value?: DateSingle;
+    defaultValue?: DateSingle;
+    onChange?: (date: DateSingle) => void;
+};
+
+export declare const Skeleton: {
+    ({ isCircle, width, height, isLoading, ...props }: Props_22): string | number | bigint | true | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element;
+    displayName: string;
+};
+
+export declare const Stack: ForwardRefExoticComponent<Omit<StackProps, "ref"> & RefAttributes<HTMLDivElement>>;
+
+declare interface StackProps extends ComponentProps<"div"> {
+    inline?: boolean;
+    justify?: CSSProperties["justifyContent"];
+    align?: CSSProperties["alignItems"];
+    direction?: "horizontal" | "vertical";
+    gap?: CSSProperties["gap"];
+}
+
+export declare type State<T> = [T, SetState<T>];
+
+export declare function Stepper({ items, current, onChange, className, classNameList, classNameItem, classNameButton, classNameIndicator, classNameContent, }: StepperProps): JSX.Element;
+
+export declare namespace Stepper {
+    var displayName: string;
+}
+
+export declare function StepperContainer({ current: prop, onChange, className, ...props }: StepperContainerProps): JSX.Element;
+
+export declare namespace StepperContainer {
+    var displayName: string;
+}
+
+declare interface StepperContainerProps extends Omit<HTMLProps<HTMLDivElement>, "onChange"> {
+    current?: number;
+    onChange?: (index: number) => void;
+    className?: ClassName;
+}
+
+export declare function StepperContent({ value, className, ...props }: StepperContentProps): JSX.Element | null;
+
+export declare namespace StepperContent {
+    var displayName: string;
+}
+
+declare interface StepperContentProps extends HTMLProps<HTMLDivElement> {
+    value: number;
+}
+
+declare interface StepperItemProps {
+    indicator?: ReactNode;
+    title: ReactNode;
+    content?: ReactNode;
+    disabled?: boolean;
+}
+
+export declare function StepperList({ children, className, ...props }: StepperListProps): JSX.Element;
+
+export declare namespace StepperList {
+    var displayName: string;
+}
+
+declare interface StepperListProps extends HTMLProps<HTMLUListElement> {
+}
+
+declare interface StepperProps extends Omit<HTMLProps<HTMLDivElement>, "onChange"> {
+    items?: StepperItemProps[];
+    current?: number;
+    onChange?: (index: number) => void;
+    className?: ClassName;
+    classNameList?: ClassName;
+    classNameItem?: ClassName;
+    classNameButton?: ClassName;
+    classNameIndicator?: ClassName;
+    classNameContent?: ClassName;
+}
+
+export declare function StepperTrigger({ disabled, value, title, indicator, classNameItem, classNameButton, classNameIndicator, }: StepperTriggerProps): JSX.Element;
+
+export declare namespace StepperTrigger {
+    var displayName: string;
+}
+
+declare interface StepperTriggerProps {
+    indicator?: ReactNode;
+    title: ReactNode;
+    value: number;
+    disabled?: boolean;
+    classNameItem?: ClassNameValue;
+    classNameButton?: ClassNameValue;
+    classNameIndicator?: ClassNameValue;
+}
+
+declare type StyleProps = ColorProps | VariantProps_2;
+
+export declare const Switch: {
+    ({ className, children, containerProps, containerClassName, ...props }: Props_23): JSX.Element;
+    displayName: string;
+};
+
+export declare const TabContent: {
+    ({ value, ...props }: TabContentProps): JSX.Element | null;
+    displayName: string;
+};
+
+export declare interface TabContentProps extends HTMLProps<HTMLDivElement> {
+    value: string;
+}
+
+export declare const Table: {
+    <T>({ data, columns, onRowClick, selected, theadClassName, theadProps, tbodyClassName, tbodyProps, trClassName, trProps, thClassName, thProps, tdClassName, tdProps, ...tableProps }: Props_24<T>): JSX.Element;
+    displayName: string;
+};
+
+export declare const TABLE_PAGE_SIZES: number[];
+
+export declare const TableBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableCaption: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableCaptionElement> & React_2.RefAttributes<HTMLTableCaptionElement>>;
+
+export declare const TableCell: React_2.ForwardRefExoticComponent<React_2.TdHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;
+
+export declare const TableFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TableHead: React_2.ForwardRefExoticComponent<React_2.ThHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;
+
+export declare const TableHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+
+export declare const TablePagination: {
+    ({ containerClassName, containerProps, selectClassName, selectProps, sizes, ...props }: Props_25): JSX.Element;
+    displayName: string;
+};
+
+declare interface TablePaginationExtendedProps {
+    containerClassName?: ClassName;
+    containerProps?: HTMLProps<HTMLDivElement>;
+    selectClassName?: ClassName;
+    selectProps?: HTMLProps<HTMLSelectElement>;
+    sizes?: PageSize[] | false;
+}
+
+export declare const TableRoot: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & {
+    containerClassName?: ContainerProps["className"];
+    containerProps?: ContainerProps;
+} & React_2.RefAttributes<HTMLTableElement>>;
+
+export declare const TableRow: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableRowElement> & React_2.RefAttributes<HTMLTableRowElement>>;
+
+export declare const TabList: {
+    ({ children, className }: TabListProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface TabListProps {
+    children: ReactNode;
+    className?: string;
+}
+
+export declare const Tabs: {
+    ({ children, value: prop, onChange, defaultValue, ...props }: TabsProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface TabsExtendedProps extends TabsProps {
+    listClassName: TabListProps["className"];
+    listProps: TabListProps;
+    triggerClassName: TabTriggerProps["className"];
+    triggerProps: TabTriggerProps;
+    contentClassName: TabContentProps["className"];
+    contentProps: TabContentProps;
+}
+
+export declare interface TabsProps extends Omit<HTMLProps<HTMLDivElement>, "value" | "defaultValue" | "onChange"> {
+    value?: string;
+    onChange?: (tab: string) => void;
+    defaultValue?: string;
+}
+
+export declare const TabTrigger: {
+    ({ value, className, ...props }: TabTriggerProps): JSX.Element;
+    displayName: string;
+};
+
+export declare interface TabTriggerProps extends Omit<HTMLProps<HTMLButtonElement>, "onClick" | "type"> {
+    value: string;
+}
+
+export declare const Tag: ForwardRefExoticComponent<Props_26 & RefAttributes<HTMLDivElement>>;
+
+export declare type TagVariant = VariantProps<typeof tagVariants>;
+
+export declare const tagVariants: (props?: ({
+    rounded?: "default" | "square" | "full" | null | undefined;
+    variant?: "error" | "success" | "outline" | "secondary" | "primary" | "borderless" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const TextArea: ForwardRefExoticComponent<Omit<TextAreaProps, "ref"> & RefAttributes<HTMLTextAreaElement>>;
+
+declare type TextAreaProps = HTMLProps<HTMLTextAreaElement>;
+
+export declare const Timeline: ({ items, classNameContainer, containerProps, ...itemsProps }: TimelineProps) => JSX.Element;
+
+export declare const TimelineItemContent: (props: HTMLProps<HTMLDivElement>) => JSX.Element;
+
+export declare const TimelineItemDot: ({ icon, status, color, classNameDot, classNameContainerDot, }: TimelineItemDotProps) => JSX.Element;
+
+declare interface TimelineItemDotProps {
+    icon?: ReactNode;
+    status?: "done" | "pending" | "error";
+    color?: string;
+    classNameDot?: string;
+    classNameContainerDot?: string;
+}
+
+export declare const TimelineListItem: ({ icon, status, color, classNameItemDot, classNameItemContainerDot, classNameItemContent, itemsProps, children, ...props }: TimelineListItemProps) => JSX.Element;
+
+declare interface TimelineListItemProps extends HTMLProps<HTMLLIElement> {
+    icon?: ReactNode;
+    status?: "done" | "pending" | "error";
+    color?: string;
+    itemsProps?: HTMLProps<HTMLDivElement>;
+    classNameContainer?: string;
+    classNameItemDot?: string;
+    classNameItemContainerDot?: string;
+    classNameItemContent?: string;
+}
+
+declare interface TimelineProps {
+    items: ItemTimeline[];
+    itemsProps?: HTMLProps<HTMLDivElement>;
+    containerProps?: HTMLProps<HTMLUListElement>;
+    classNameContainer?: string;
+    classNameItem?: string;
+    classNameItemDot?: string;
+    classNameItemContainerDot?: string;
+    classNameItemContent?: string;
+}
+
+export declare const TimelineRoot: (props: HTMLProps<HTMLUListElement>) => JSX.Element;
+
+export declare const Toast: ForwardRefExoticComponent<globalThis.Omit<Props_27, "ref"> & RefAttributes<HTMLDivElement>>;
+
+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>;
+};
+
+export declare type ToastArgs = string | Omit<ToastProperties, "type">;
+
+export declare const Toaster: {
+    ({ iconClassName, ...props }: ToasterProps): JSX.Element;
+    displayName: string;
+};
+
+export declare type ToasterProps = React.ComponentProps<"div"> & {
+    iconClassName?: string;
+};
+
+export declare const ToastIcons: Record<ToastType, ComponentType<LucideProps>>;
+
+export declare interface ToastPromiseOptions<T> {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((error: any) => string);
+}
+
+export declare interface ToastProperties extends Omit<IToast, "id"> {
+    duration?: number;
+}
+
+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 type ToastType = "info" | "success" | "error" | "loading";
+
+export declare const Tooltip: {
+    ({ label, open: prop, defaultOpen: defaultProp, onOpenChange: onChange, className, side, offset, ...props }: Props_28): JSX.Element;
+    displayName: string;
+};
+
+export declare function Tree<T extends TreeNode>({ items, ...props }: Props_29<T>): JSX.Element;
+
+export declare const TreeItem: <T extends object>({ className, ...props }: OverrideProps<TreeItemProps<T>, {
+    id: string | number;
+}>) => JSX.Element;
+
+export declare const TreeItemContent: (props: React_2.ComponentProps<typeof UNSTABLE_TreeItemContent>) => JSX.Element;
+
+export declare const TreeItemIndicator: () => JSX.Element;
+
+export declare const TreeItemLabel: (props: React_2.HtmlHTMLAttributes<HTMLSpanElement>) => JSX.Element;
+
+export declare interface TreeNode {
+    id: string | number;
+    title: string;
+    children: TreeNode[];
+}
+
+export declare const TreeRoot: <T extends object>({ className, ...props }: TreeProps<T>) => JSX.Element;
+
+declare type TreeRootProps = React_2.ComponentProps<typeof TreeRoot>;
+
+export declare const twMerge: (...classLists: ClassNameValue[]) => string;
+
+export declare const type: (element: HTMLElement, value: string) => void;
+
+export declare const UploadAcceptedFiles: (props: UploadFilesProps) => JSX.Element;
+
+export declare const UploadContent: ({ className, ...props }: UploadContentProps) => JSX.Element;
+
+declare type UploadContentProps = ComponentPropsWithoutRef<"div"> & {
+    renderRejectedFile?: (file: File) => ReactNode;
+};
+
+declare type UploadFilesListProps = {
+    files: File[];
+    handleFileRemove: (index: number, type: "accepted" | "rejected") => void;
+    fileType: "accepted" | "rejected";
+    children?: ReactNode;
+    renderFile?: (file: File, removeItem: () => void) => ReactNode;
+};
+
+declare type UploadFilesProps = Omit<UploadFilesListProps, "fileType" | "handleFileRemove" | "files">;
+
+export declare const UploadItem: ({ file, onRemove, className, renderIcon, ...props }: UploadItemProps) => JSX.Element;
+
+declare type UploadItemProps = ComponentPropsWithoutRef<"div"> & {
+    file: File;
+    onRemove: () => void;
+    renderIcon?: (file: File) => ReactNode;
+};
+
+export declare const UploadRejectedFiles: (props: UploadFilesProps) => JSX.Element;
+
+export declare const UploadRoot: ({ onFileAdd, onFileRemove, onChangeFiles, files: prop, maxFiles, allowedExtensions, maxFileSize, multiple, children, ...props }: UploadRootProps) => JSX.Element;
+
+declare type UploadRootProps = {
+    onFileAdd?: (files: File[]) => void;
+    onFileRemove?: (index: number, type: "accepted" | "rejected") => void;
+    onChangeFiles?: (files: File[]) => void;
+    files?: File[];
+    maxFiles?: number;
+    allowedExtensions?: string[];
+    maxFileSize?: number;
+    multiple?: true;
+    className?: string;
+    children?: ReactNode;
+};
+
+export declare const UploadTrigger: ({ asChild, ...props }: UploadTriggerProps) => JSX.Element;
+
+declare type UploadTriggerProps = {
+    asChild?: boolean;
+} & ComponentPropsWithoutRef<"button">;
+
+export declare function useArray<T>(defaultProp: T[]): readonly [T[], {
+    readonly insertAt: (index: number, item: T) => void;
+    readonly removeAt: (index: number) => void;
+    readonly updateAt: (index: number, newItem: T) => void;
+    readonly clear: () => void;
+    readonly reset: () => void;
+    readonly push: (item: T) => void;
+    readonly set: (newList: T[]) => void;
+    readonly pop: () => void;
+    readonly update: (predicate: ListIterateeCustom<T, boolean>, newItem: T | ((item: T) => T)) => void;
+}];
+
+export declare function useAsync<T>({ fn, dependencies, onError, onSuccess, onFinish, }: Props_30<T>): AsyncState<T>;
+
+declare interface UseAsyncOptions<T> {
+    onError?: (error: Error) => void;
+    onSuccess?: (data: T) => void;
+    onFinish?: () => void;
+}
+
+export declare const useClickOutside: <T extends HTMLElement = HTMLElement>(callback: () => void, watch?: boolean) => RefObject<T | null>;
+
+export declare function useClipboard(): [CopiedValue, CopyFunction];
+
+export { useControllableState }
+
+export declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, delay: number): (...args: Parameters<T>) => void;
+
+export declare function useDebouncedValue<T>(value: T, delay: number): T;
+
+export declare function useDisclosure(initialState?: boolean, callbacks?: {
+    onOpen?: () => void;
+    onClose?: () => void;
+}): readonly [boolean, {
+    readonly open: () => void;
+    readonly close: () => void;
+    readonly toggle: () => void;
+}];
+
+export declare function useDocumentTitle(title: string): void;
+
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): RefObject<T | null>;
+
+export declare function useFocusTrap(active?: boolean): (instance: HTMLElement | null) => void;
+
+export declare function useForm<T extends FieldValues = FieldValues>(schema: ZodType<T>, options?: Partial<UseFormProps<T>>): UseFormReturn<T, any, undefined>;
+
+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): {
+    ref: React.RefObject<T | null>;
+    isHovering: boolean;
+};
+
+declare type UseHoverOptions = {
+    onHoverStart?: (event: MouseEvent) => void;
+    onHoverEnd?: (event: MouseEvent) => void;
+};
+
+export declare function useIsVisible<T extends HTMLElement>({ onVisible, root, rootMargin, threshold, }?: UseIsVisibleProps): UseIsVisibleReturn<T>;
+
+declare interface UseIsVisibleProps extends IntersectionObserverInit {
+    onVisible?: () => void;
+}
+
+declare interface UseIsVisibleReturn<T> {
+    ref: RefObject<T | null>;
+    isVisible: boolean;
+}
+
+export declare function useLocalStorage<T>(key: string): [T | undefined, (value: T) => void, () => void];
+
+export declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void, () => void];
+
+export declare const useMediaQuery: (query: string) => boolean;
+
+export declare function useMemoizedFn<T extends noop>(fn: T): T;
+
+export declare const useMutation: <TArgs extends any[], TReturn>(opts: UseMutationOptions<TArgs, TReturn>) => UseMutationReturn<TArgs, TReturn>;
+
+declare interface UseMutationOptions<TArgs extends any[], TReturn> {
+    fn: Mutation<TArgs, TReturn>;
+    onError?: (error: Error) => void;
+    onSuccess?: (data: TReturn) => void;
+    onFinish?: () => void;
+}
+
+declare interface UseMutationReturn<TArgs extends any[], TReturn> {
+    mutate: Mutation<TArgs, TReturn>;
+    loading: boolean;
+    error: Error | null;
+    data: TReturn | null;
+}
+
+export declare function useObject<T extends GenericObject_2>(): MaybeReturn<T>;
+
+export declare function useObject<T extends GenericObject_2>(initialValue: T): Return<T>;
+
+export declare function usePagination({ totalItems, pageSize, initialCurrentPage, onChange, }: usePaginationProps): {
+    next: () => void;
+    prev: () => void;
+    goTo: (page: number) => void;
+    currentPage: number;
+    maxPage: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    range: {
+        start: number;
+        end: number;
+    };
+};
+
+export declare type usePaginationProps = {
+    /**
+     * Cantidad total de elementos
+     */
+    totalItems: number;
+    /**
+     * Cantidad de elementos por página
+     */
+    pageSize: number;
+    /**
+     * Pagina inicial
+     */
+    initialCurrentPage?: number;
+    /**
+     * Callback que se ejecuta cuando cambia la pagina
+     */
+    onChange?: (value: {
+        currentPage: number;
+        pageSize: number;
+    }) => void;
+    siblingCount?: number;
+};
+
+export declare function usePortal(id: string): {
+    render: (children: ReactNode) => ReactPortal | null;
+};
+
+export declare function usePreventCloseWindow({ shouldPrevent, message, }: UsePreventUnloadProps): void;
+
+declare interface UsePreventUnloadProps {
+    /**
+     * Propiedad que determina si la ventana se puede cerrar o no
+     */
+    shouldPrevent: boolean;
+    /**
+     * Mensaje que se va a mostrar al usuario antes de cerrar la ventana
+     * @deprecated ya no es soportado por los navegadores modernos
+     */
+    message?: string;
+}
+
+export declare const useRangePagination: ({ siblingCount, ...paginationProps }: useRangePaginationProps) => {
+    paginationRange: (string | number)[];
+    next: () => void;
+    prev: () => void;
+    goTo: (page: number) => void;
+    currentPage: number;
+    maxPage: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    range: {
+        start: number;
+        end: number;
+    };
+};
+
+export declare type useRangePaginationProps = {
+    /**
+     * Cantidad de elementos visibles al lado de la pagina actual
+     */
+    siblingCount?: number;
+} & usePaginationProps;
+
+export declare function useSelection<T>(items: T[]): Return_2<T>;
+
+export declare function useStep<T = ReactNode>(steps: T[], amountSteps?: number): Return_3<T>;
+
+export declare const useToastStore: UseBoundStore<StoreApi<ToastStore>>;
+
+export declare function useToggle(initialValue?: boolean): Return_4;
+
+export declare type ValuesUnion<T extends Record<string, any>> = T[keyof T];
+
+declare type VariantProps_2 = {
+    color?: never;
+    variant?: TagVariant["variant"];
+};
+
+export declare interface ViewProps {
+    value: Date;
+    onChange: (date: Date) => void;
+}
+
+declare type WeekDaysProps = HTMLProps<HTMLDivElement>;
+
+export declare const weeksDays: string[];
+
+export { }
+
+
+export declare namespace Stepper {
+    var displayName: string;
+}
+
+
+export declare namespace StepperContainer {
+    var displayName: string;
+}
+
+
+export declare namespace StepperList {
+    var displayName: string;
+}
+
+
+export declare namespace StepperTrigger {
+    var displayName: string;
+}
+
+
+export declare namespace StepperContent {
+    var displayName: string;
+}
+