@blencm/ui 0.0.1

package/dist/components/searchable-select.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { type CustomSize, type SizeProps, type VariantProps } from "../utils/form-utils";
+type SearchableSelectOption<TData = unknown> = {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+    keywords?: string;
+    data?: TData;
+};
+type SearchableSelectProps<TData = unknown> = {
+    items: SearchableSelectOption<TData>[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string, item?: SearchableSelectOption<TData>) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: React.ReactNode;
+    disabled?: boolean;
+    name?: string;
+    required?: boolean;
+    invalid?: boolean;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    variant?: VariantProps;
+    classNameDefault?: boolean;
+    triggerClassName?: string;
+    contentClassName?: string;
+    itemClassName?: string;
+    searchInputClassName?: string;
+};
+declare function SearchableSelectBase<TData = unknown>({ items, value, defaultValue, onValueChange, placeholder, searchPlaceholder, emptyText, disabled, name, required, invalid, size, customSize, variant, classNameDefault, triggerClassName, contentClassName, itemClassName, searchInputClassName, }: SearchableSelectProps<TData>): React.JSX.Element;
+declare const SearchableSelect: typeof SearchableSelectBase;
+export { SearchableSelect, type SearchableSelectOption, type SearchableSelectProps, };

package/dist/components/select.d.ts

@@ -0,0 +1,69 @@
+import * as React from "react";
+import { type CustomSize, type SizeProps, type VariantProps } from "../utils/form-utils";
+type SelectAlign = "start" | "center" | "end";
+export type SelectProps = {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    name?: string;
+    required?: boolean;
+    variant?: VariantProps;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    invalid?: boolean;
+    children: React.ReactNode;
+};
+declare function Select({ value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, disabled, name, required, variant, size, customSize, invalid, children, }: SelectProps): React.JSX.Element;
+export type SelectTriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+    variant?: VariantProps;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    invalid?: boolean;
+};
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+    variant?: VariantProps;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    invalid?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+export type SelectValueProps = React.HTMLAttributes<HTMLSpanElement> & {
+    placeholder?: React.ReactNode;
+};
+declare const SelectValue: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLSpanElement> & {
+    placeholder?: React.ReactNode;
+} & React.RefAttributes<HTMLSpanElement>>;
+export type SelectContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    position?: "popper";
+    sideOffset?: number;
+    align?: SelectAlign;
+};
+declare const SelectContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    position?: "popper";
+    sideOffset?: number;
+    align?: SelectAlign;
+} & React.RefAttributes<HTMLDivElement>>;
+export type SelectGroupProps = React.HTMLAttributes<HTMLDivElement>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+export type SelectLabelProps = React.HTMLAttributes<HTMLDivElement>;
+declare const SelectLabel: React.ForwardRefExoticComponent<SelectLabelProps & React.RefAttributes<HTMLDivElement>>;
+export type SelectItemProps = Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    value: string;
+    disabled?: boolean;
+    textValue?: string;
+    size?: SizeProps;
+    customSize?: CustomSize;
+};
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    value: string;
+    disabled?: boolean;
+    textValue?: string;
+    size?: SizeProps;
+    customSize?: CustomSize;
+} & React.RefAttributes<HTMLDivElement>>;
+export type SelectSeparatorProps = React.HTMLAttributes<HTMLDivElement>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<SelectSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/components/separator.d.ts

@@ -0,0 +1,4 @@
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as React from 'react';
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/components/sheet.d.ts

@@ -0,0 +1,25 @@
+import * as SheetPrimitive from '@radix-ui/react-dialog';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const Sheet: typeof SheetPrimitive.Root;
+declare const SheetTrigger: typeof SheetPrimitive.Trigger;
+declare const SheetClose: typeof SheetPrimitive.Close;
+declare const SheetPortal: typeof SheetPrimitive.Portal;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "bottom" | "left" | "right" | "top" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare function SheetHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare namespace SheetHeader {
+    var displayName: string;
+}
+declare function SheetFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+declare namespace SheetFooter {
+    var displayName: string;
+}
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger };

package/dist/components/skeleton.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+export { Skeleton };

package/dist/components/slider.d.ts

@@ -0,0 +1,4 @@
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as React from 'react';
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

package/dist/components/sonner.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { Toaster as Sonner } from 'sonner';
+export type SonnerToasterProps = React.ComponentProps<typeof Sonner>;
+declare const ToasterSonner: ({ ...props }: SonnerToasterProps) => React.JSX.Element;
+export { ToasterSonner, ToasterSonner as SonnerToaster };

package/dist/components/switch.d.ts

@@ -0,0 +1,4 @@
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as React from 'react';
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/components/table.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & {
+    containerClassName?: string;
+} & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, };

package/dist/components/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as React from 'react';
+declare const Tabs: typeof TabsPrimitive.Root;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsContent, TabsList, TabsTrigger };

package/dist/components/textarea.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { type CustomSize, type SizeProps, type VariantProps } from "../utils/form-utils";
+export interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    size?: SizeProps;
+    customSize?: CustomSize;
+    variant?: VariantProps;
+    invalid?: boolean;
+    classNameDefault?: boolean;
+    placeholder?: string;
+    className?: string;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/components/toast.d.ts

@@ -0,0 +1,15 @@
+import * as ToastPrimitives from '@radix-ui/react-toast';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const ToastProvider: typeof ToastPrimitives.Provider;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { Toast, ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, type ToastActionElement, type ToastProps };

package/dist/components/toaster.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare function Toaster(): React.JSX.Element;

package/dist/components/toggle-group.d.ts

@@ -0,0 +1,12 @@
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

package/dist/components/toggle.d.ts

@@ -0,0 +1,12 @@
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

package/dist/components/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as React from 'react';
+declare const TooltipProvider: typeof TooltipPrimitive.Provider;
+declare const Tooltip: typeof TooltipPrimitive.Root;
+declare const TooltipTrigger: typeof TooltipPrimitive.Trigger;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/components/ui/input.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { type InputProps } from '../input';
+export interface UiInputProps extends Omit<InputProps, 'id'> {
+    label?: React.ReactNode;
+    errorMessage?: string;
+    htmlFormItemId?: string;
+    requiredLabel?: boolean;
+    requiredLabelClassName?: string;
+    containerClassName?: string;
+    labelClassName?: string;
+    messageClassName?: string;
+}
+declare const UiInput: React.ForwardRefExoticComponent<UiInputProps & React.RefAttributes<HTMLInputElement>>;
+export { UiInput };

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

@@ -0,0 +1,37 @@
+import * as React from "react";
+import { type CustomSize, type SizeProps, type VariantProps } from "../../utils/form-utils";
+export type UiSelectOption<TData = unknown> = {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+    data?: TData;
+};
+export interface UiSelectProps<TData = unknown> {
+    label?: React.ReactNode;
+    placeholder?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    items?: UiSelectOption<TData>[];
+    children?: React.ReactNode;
+    disabled?: boolean;
+    requiredLabel?: boolean;
+    className?: string;
+    selectClassName?: string;
+    labelClassName?: string;
+    contentClassName?: string;
+    itemClassName?: string;
+    messageClassName?: string;
+    requiredLabelClassName?: string;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    variant?: VariantProps;
+    classNameDefault?: boolean;
+    errorMessage?: string;
+    htmlFormItemId?: string;
+    position?: "popper";
+    contentAlign?: "start" | "center" | "end";
+    contentSideOffset?: number;
+}
+declare function UiSelect<TData = unknown>({ label, placeholder, value, defaultValue, onChange, items, children, disabled, requiredLabel, className, selectClassName, labelClassName, contentClassName, itemClassName, messageClassName, requiredLabelClassName, size, customSize, variant, errorMessage, htmlFormItemId, position, contentAlign, contentSideOffset, }: UiSelectProps<TData>): React.JSX.Element;
+export { UiSelect };

package/dist/components/ui/ui-checkbox.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { type CheckboxProps } from "../checkbox";
+export interface UiCheckboxProps extends CheckboxProps {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    errorMessage?: string;
+    containerClassName?: string;
+    contentClassName?: string;
+    labelClassName?: string;
+    descriptionClassName?: string;
+    errorClassName?: string;
+    requiredLabelClassName?: string;
+    requiredLabel?: boolean;
+    htmlFormItemId?: string;
+}
+declare const UiCheckbox: React.ForwardRefExoticComponent<UiCheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+export { UiCheckbox };

package/dist/components/ui/ui-date.d.ts

@@ -0,0 +1,44 @@
+import * as React from "react";
+import { type Locale } from "date-fns";
+import { type CustomSize, type SizeProps, type VariantProps } from "../../utils/form-utils";
+import { type DateFormatValue } from "../../utils/date-formats";
+type DateInputValue = Date | string | null | undefined;
+export interface UiDateProps {
+    label?: React.ReactNode;
+    placeholder?: string;
+    value?: Date | string | null;
+    defaultMonth?: Date;
+    onChange?: (date: Date | undefined) => void;
+    onBlur?: () => void;
+    disabled?: boolean;
+    requiredLabel?: boolean;
+    start_date?: DateInputValue;
+    end_date?: DateInputValue;
+    startDate?: DateInputValue;
+    endDate?: DateInputValue;
+    dateFormat?: DateFormatValue;
+    valueFormat?: DateFormatValue;
+    formatPattern?: string;
+    valueFormatPattern?: string;
+    locale?: Locale | null;
+    className?: string;
+    classNameDefault?: boolean;
+    dateClassName?: string;
+    labelClassName?: string;
+    contentClassName?: string;
+    messageClassName?: string;
+    requiredLabelClassName?: string;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    variant?: VariantProps;
+    errorMessage?: string;
+    invalid?: boolean;
+    htmlFormItemId?: string;
+    contentAlign?: "start" | "center" | "end";
+    contentSideOffset?: number;
+}
+declare function UiDate({ label, placeholder, value, defaultMonth, onChange, onBlur, disabled, requiredLabel, start_date, end_date, startDate, endDate, dateFormat, valueFormat, formatPattern, valueFormatPattern, locale, className, classNameDefault, dateClassName, labelClassName, contentClassName, messageClassName, requiredLabelClassName, size, customSize, variant, errorMessage, invalid, htmlFormItemId, contentAlign, contentSideOffset, }: UiDateProps): React.JSX.Element;
+declare namespace UiDate {
+    var displayName: string;
+}
+export { UiDate };

package/dist/components/ui/ui-textarea.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { type TextareaProps } from "../textarea";
+export interface UiTextareaProps extends Omit<TextareaProps, "id"> {
+    label?: React.ReactNode;
+    errorMessage?: string;
+    htmlFormItemId?: string;
+    requiredLabel?: boolean;
+    requiredLabelClassName?: string;
+    containerClassName?: string;
+    labelClassName?: string;
+    messageClassName?: string;
+}
+declare const UiTextarea: React.ForwardRefExoticComponent<UiTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { UiTextarea };

package/dist/components/ui/ui-time.d.ts

@@ -0,0 +1,58 @@
+import * as React from "react";
+import { type Locale } from "date-fns";
+import { type CustomSize, type SizeProps, type VariantProps } from "../../utils/form-utils";
+import { type TimeFormatValue } from "../../utils/time-formats";
+export type UiTimeOption = {
+    value: string;
+    label?: React.ReactNode;
+    disabled?: boolean;
+};
+type HourCycle = "12" | "24";
+export interface UiTimeProps {
+    label?: React.ReactNode;
+    placeholder?: string;
+    value?: Date | string | null;
+    onChange?: (date: Date | undefined) => void;
+    onBlur?: () => void;
+    disabled?: boolean;
+    requiredLabel?: boolean;
+    timeFormat?: TimeFormatValue;
+    valueFormat?: TimeFormatValue;
+    formatPattern?: string;
+    valueFormatPattern?: string;
+    locale?: Locale;
+    /**
+     * 1 = selector minuto por minuto.
+     * 5, 10, 15, 30 también funcionan.
+     */
+    minuteStep?: number;
+    minTime?: string;
+    maxTime?: string;
+    /**
+     * Si envías options, se renderiza como lista simple.
+     * Para el picker tipo imagen, no mandes options.
+     */
+    options?: UiTimeOption[];
+    hourCycle?: HourCycle;
+    className?: string;
+    classNameDefault?: boolean;
+    timeClassName?: string;
+    labelClassName?: string;
+    contentClassName?: string;
+    optionClassName?: string;
+    messageClassName?: string;
+    requiredLabelClassName?: string;
+    size?: SizeProps;
+    customSize?: CustomSize;
+    variant?: VariantProps;
+    errorMessage?: string;
+    invalid?: boolean;
+    htmlFormItemId?: string;
+    contentAlign?: "start" | "center" | "end";
+    contentSideOffset?: number;
+}
+declare function UiTime({ label, placeholder, value, onChange, onBlur, disabled, requiredLabel, timeFormat, valueFormat, formatPattern, valueFormatPattern, locale, minuteStep, minTime, maxTime, options, hourCycle, className, classNameDefault, timeClassName, labelClassName, contentClassName, optionClassName, messageClassName, requiredLabelClassName, size, customSize, variant, errorMessage, invalid, htmlFormItemId, contentAlign, contentSideOffset, }: UiTimeProps): React.JSX.Element;
+declare namespace UiTime {
+    var displayName: string;
+}
+export { UiTime };

package/dist/components/use-toast.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import type { ToastActionElement, ToastProps } from './toast';
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: 'ADD_TOAST';
+    readonly UPDATE_TOAST: 'UPDATE_TOAST';
+    readonly DISMISS_TOAST: 'DISMISS_TOAST';
+    readonly REMOVE_TOAST: 'REMOVE_TOAST';
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType['ADD_TOAST'];
+    toast: ToasterToast;
+} | {
+    type: ActionType['UPDATE_TOAST'];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType['DISMISS_TOAST'];
+    toastId?: ToasterToast['id'];
+} | {
+    type: ActionType['REMOVE_TOAST'];
+    toastId?: ToasterToast['id'];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, 'id'>;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toasts: ToasterToast[];
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+};
+export { useToast, toast };

package/dist/helper/time.d.ts

@@ -0,0 +1 @@
+export declare function isSameHourMinute(first?: Date, second?: Date): boolean;

package/dist/hooks/use-sidebar.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const useSidebar: () => {
+    isMinimized: boolean;
+    toggle: () => void;
+};
+export declare const SidebarProvider: React.FC<{
+    children: React.ReactNode;
+}>;