@companix/uikit 0.0.2 → 0.0.3

package/dist/bundle.es9.js

@@ -0,0 +1,47 @@
+import { jsxs as a, jsx as e } from "react/jsx-runtime";
+/* empty css            */
+import { Form as u } from "./bundle.es11.js";
+import { useStepperInput as f } from "./bundle.es35.js";
+import { usePress as h } from "./bundle.es36.js";
+import { Button as v } from "./bundle.es3.js";
+import { attr as x } from "@companix/utils-browser";
+import { Icon as m } from "./bundle.es37.js";
+import { faChevronUp as C, faChevronDown as b } from "@fortawesome/free-solid-svg-icons";
+const y = ({ inputStyle: r, placeholder: t, buttons: n, ...o }) => {
+  const { inputRef: s, increment: p, decrement: i, handleChange: d, value: l } = f(o);
+  return /* @__PURE__ */ a("div", { className: "number-input-container", children: [
+    /* @__PURE__ */ e(
+      u,
+      {
+        ref: s,
+        placeholder: t,
+        style: r,
+        value: l,
+        onChange: d
+      }
+    ),
+    n && /* @__PURE__ */ e(I, { increment: p, decrement: i })
+  ] });
+}, I = ({ increment: r, decrement: t }) => /* @__PURE__ */ a("div", { className: "number-stepper", children: [
+  /* @__PURE__ */ e(c, { slot: "increment", onClick: r, children: /* @__PURE__ */ e(m, { size: "xxs", icon: C }) }),
+  /* @__PURE__ */ e("div", { className: "number-stepper-splitter" }),
+  /* @__PURE__ */ e(c, { slot: "decrement", onClick: t, children: /* @__PURE__ */ e(m, { size: "xxs", icon: b }) })
+] }), c = ({ children: r, slot: t, onClick: n }) => {
+  const { pressProps: o, isPressed: s } = h({ onClick: n, preventFocusOnPress: !0 }), { onBeforeInput: p, ...i } = o;
+  return /* @__PURE__ */ e(
+    v,
+    {
+      ...i,
+      onBeforeInput: p,
+      "data-slot": t,
+      "data-size": void 0,
+      "data-pressed": x(s),
+      style: { border: "none" },
+      className: "number-stepper-slot",
+      children: r
+    }
+  );
+};
+export {
+  y as StepperInput
+};

package/dist/types/Button/index.d.ts

@@ -0,0 +1,20 @@
+export type Appearance = 'primary' | 'neutral' | 'positive' | 'negative';
+export type Mode = 'default' | 'outline' | 'minimal';
+export type Size = 'sm' | 'md' | 'lg';
+export interface InternButtonProps {
+    icon?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    appearance?: Appearance;
+    mode?: Mode;
+    size?: Size;
+    fill?: boolean;
+    align?: 'left' | 'center' | 'right';
+    loading?: boolean;
+    active?: boolean;
+    text?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+}
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, InternButtonProps {
+}
+export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/types/ButtonGroup/index.d.ts

@@ -0,0 +1,7 @@
+interface ButtonGroupProps {
+    children: React.ReactNode;
+    className?: string;
+    fill?: boolean;
+}
+export declare const ButtonGroup: import('react').ForwardRefExoticComponent<ButtonGroupProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/Checkbox/index.d.ts

@@ -0,0 +1,10 @@
+interface CheckboxProps {
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    size?: 'sm' | 'md';
+    label?: React.ReactNode;
+    disabled?: boolean;
+    required?: boolean;
+}
+declare const Checkbox: ({ checked, required, disabled, onCheckedChange, size, label }: CheckboxProps) => import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/types/Countdown/index.d.ts

@@ -0,0 +1,7 @@
+interface CountDownProps {
+    expiration: number;
+    separator?: string;
+    onExpired?: VoidFunction;
+}
+export declare const Countdown: ({ expiration, separator, onExpired }: CountDownProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/DateInput/index.d.ts

@@ -0,0 +1,13 @@
+import { DateFormat } from '..';
+export interface DatePickerProps {
+    min?: DateFormat;
+    max?: DateFormat;
+    noDaySelect?: boolean;
+    noYearSelect?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    value: DateFormat;
+    onChange: (e: DateFormat) => void;
+}
+export declare const DateInput: ({ min, max, disabled, value, noDaySelect, noYearSelect, onChange, required, size }: DatePickerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/DatePicker/Calendar.d.ts

@@ -0,0 +1,14 @@
+export interface CalendarProps {
+    value?: Date | null;
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    enableTime?: boolean;
+    disablePickers?: boolean;
+    showNeighboringMonth?: boolean;
+    onChange?: (value: Date) => void;
+    shouldDisableDate?: (value: Date) => boolean;
+    viewDate?: Date;
+    minDateTime?: Date;
+    maxDateTime?: Date;
+}
+export declare const Calendar: ({ disablePickers, value, onChange, ...props }: CalendarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/DatePicker/CalendarHeader.d.ts

@@ -0,0 +1,10 @@
+export interface CalendarHeaderProps {
+    viewDate: Date;
+    disablePickers?: boolean;
+    isMonthDisabled?: (monthNumber: number, year?: number) => boolean;
+    isYearDisabled?: (yearNumber: number) => boolean;
+    onChange: (viewDate: Date) => void;
+    onNextMonth?: () => void;
+    onPrevMonth?: () => void;
+}
+export declare const CalendarHeader: ({ viewDate, onChange, isMonthDisabled, isYearDisabled, onNextMonth, onPrevMonth }: CalendarHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/DatePicker/index.d.ts

@@ -0,0 +1,12 @@
+import { FormProps } from '../Form';
+import { CalendarProps } from './Calendar';
+interface DatePickerProps extends Omit<CalendarProps, 'onChange'>, Omit<FormProps, 'value' | 'onChange' | 'rightElement'> {
+    onChange?: (value: Date | null) => void;
+    placeholder?: string;
+    clearButton?: boolean;
+    clearButtonIcon?: boolean;
+    children?: React.ReactNode;
+    minimalOptions?: boolean;
+}
+export declare const DatePicker: (props: DatePickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Dialog/index.d.ts

@@ -0,0 +1,12 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export interface DialogProps {
+    open: boolean;
+    onOpenChange: (value: boolean) => void;
+    children: React.ReactNode;
+    size?: 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl' | 'full';
+    className?: string;
+}
+export declare const Dialog: {
+    ({ size, open, onOpenChange, children, className }: DialogProps): import("react/jsx-runtime").JSX.Element;
+    Close: import('react').ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & import('react').RefAttributes<HTMLButtonElement>>;
+};

package/dist/types/DialogAlert/Alert.d.ts

@@ -0,0 +1,19 @@
+import { InternButtonProps } from '../Button';
+interface ActionProps extends Omit<InternButtonProps, 'children'> {
+    onClick?: () => void;
+}
+export interface AlertDialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (value: boolean) => void;
+    onUnMounted?: () => void;
+    icon?: React.ReactNode;
+    title?: string;
+    description?: string;
+    confirm?: ActionProps;
+    cancel?: ActionProps;
+    cancelDefaultText?: string;
+    disableCancel?: boolean;
+}
+export declare const AlertDialog: ({ open, defaultOpen, onOpenChange, onUnMounted, icon, title, description, cancelDefaultText, cancel, disableCancel, confirm }: AlertDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/DialogAlert/Viewport.d.ts

@@ -0,0 +1,8 @@
+import { InnerAlert } from '.';
+import { AlertDialogProps } from './Alert';
+export interface ViewportRef {
+    showAlert: (alert: InnerAlert) => void;
+}
+export interface AlertBaseProps extends Pick<AlertDialogProps, 'cancelDefaultText'> {
+}
+export declare const Viewport: import('react').ForwardRefExoticComponent<AlertBaseProps & import('react').RefAttributes<ViewportRef>>;

package/dist/types/DialogAlert/index.d.ts

@@ -0,0 +1,11 @@
+import { AlertDialogProps } from './Alert';
+import { AlertBaseProps } from './Viewport';
+export interface AlertOptions extends Omit<AlertDialogProps, 'open' | 'onOpenChange'> {
+}
+export interface InnerAlert extends AlertOptions {
+    id: string;
+}
+export declare const createAlertAgent: (options?: AlertBaseProps) => {
+    show: (value: Omit<InnerAlert, "id">) => void;
+    Viewport: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/types/Drawer/index.d.ts

@@ -0,0 +1,13 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export interface DrawerProps {
+    open: boolean;
+    onOpenChange: (value: boolean) => void;
+    children: React.ReactNode;
+    direction?: 'bottom' | 'top' | 'left' | 'right';
+    className?: string;
+    size?: string;
+}
+export declare const Drawer: {
+    ({ open, onOpenChange, children, size, direction, className }: DrawerProps): import("react/jsx-runtime").JSX.Element;
+    Close: import('react').ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & import('react').RefAttributes<HTMLButtonElement>>;
+};

package/dist/types/File/index.d.ts

@@ -0,0 +1,10 @@
+export interface FileOverlayProps {
+    multiple?: true;
+    onChange?: (file: File[]) => void;
+    children: React.ReactNode;
+    mimes?: string[];
+    disabled?: boolean;
+    className?: string;
+}
+declare const FileOverlay: ({ onChange, disabled, mimes, children, multiple, className }: FileOverlayProps) => import("react/jsx-runtime").JSX.Element;
+export { FileOverlay };

package/dist/types/Form/index.d.ts

@@ -0,0 +1,17 @@
+export interface FormProps extends React.HTMLAttributes<HTMLDivElement> {
+    required?: boolean;
+    disabled?: boolean;
+    leftElement?: React.ReactNode;
+    rightElement?: React.ReactNode;
+    placeholder?: string;
+    value?: string | number;
+    readOnly?: boolean;
+    onValueChange?: (value: string, targetElement: HTMLInputElement) => void;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    inputRef?: React.RefObject<HTMLInputElement>;
+    size?: 'sm' | 'md' | 'lg';
+    fill?: boolean;
+    mask?: string;
+    maskChar?: string;
+}
+export declare const Form: import('react').ForwardRefExoticComponent<FormProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/Icon/index.d.ts

@@ -0,0 +1,7 @@
+import { IconDefinition } from '@fortawesome/free-solid-svg-icons';
+export interface IconProps {
+    icon: IconDefinition;
+    size?: 'xxxs' | 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl' | 'xxxl';
+    className?: string;
+}
+export declare const Icon: import('react').ForwardRefExoticComponent<IconProps & import('react').RefAttributes<SVGSVGElement>>;

package/dist/types/LoadButton/index.d.ts

@@ -0,0 +1,5 @@
+import { ButtonProps } from '../Button';
+import { UseLoadingProps } from '../__hooks/use-loading';
+export interface LoadButtonProps extends UseLoadingProps, Omit<ButtonProps, 'onClick'> {
+}
+export declare const LoadButton: ({ onClick, appearance, ...rest }: LoadButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/NumberInput/index.d.ts

@@ -0,0 +1,6 @@
+import { FormProps } from '../Form';
+export interface NumberInputProps extends Omit<FormProps, 'value' | 'onChange'> {
+    value: number | null;
+    onChange: (value: number | null) => void;
+}
+export declare const NumberInput: ({ value, onChange, ...props }: NumberInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/OptionItem/OptionItem.d.ts

@@ -0,0 +1,7 @@
+import { Option } from '../types';
+interface OptionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'>, Omit<Option<unknown>, 'value'> {
+    active?: boolean;
+    minimal?: boolean;
+}
+export declare const OptionItem: import('react').ForwardRefExoticComponent<OptionProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/OptionItem/OptionsList.d.ts

@@ -0,0 +1,8 @@
+interface MenuProps {
+    children: React.ReactNode;
+    maxHeight?: number;
+    scrollboxRef?: React.Ref<HTMLDivElement>;
+    optionsWrapperRef?: React.Ref<HTMLDivElement>;
+}
+export declare const OptionsList: ({ children, maxHeight, scrollboxRef, optionsWrapperRef }: MenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Popover/index.d.ts

@@ -0,0 +1,26 @@
+export type Align = 'start' | 'center' | 'end';
+export type Side = 'top' | 'right' | 'bottom' | 'left';
+export interface PopoverProps {
+    children: React.ReactNode;
+    open?: boolean;
+    triggerRef?: React.Ref<HTMLButtonElement>;
+    triggerProps?: React.ButtonHTMLAttributes<HTMLButtonElement>;
+    onOpenChange?: (open: boolean) => void;
+    content: ({ close }: {
+        close: () => void;
+    }) => React.ReactNode;
+    onAnimationEnd?: () => void;
+    onAnimationStart?: () => void;
+    onOpenAutoFocus?: (event: Event) => void;
+    onCloseAutoFocus?: (event: Event) => void;
+    side?: Side;
+    align?: Align;
+    showArrows?: boolean;
+    minimal?: boolean;
+    sideOffset?: number;
+    matchTarget?: 'width' | 'min-width';
+    className?: string;
+    fitMaxHeight?: boolean;
+    disabled?: boolean;
+}
+export declare const Popover: import('react').ForwardRefExoticComponent<PopoverProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/Radio/index.d.ts

@@ -0,0 +1,20 @@
+interface RadioOption<T> {
+    value: T;
+    label: React.ReactNode;
+}
+interface RadioGroupProps<T> {
+    options: RadioOption<T>[];
+    onChange: (event: T) => void;
+    value: T | null;
+    disabled?: boolean;
+    required?: boolean;
+    size?: 'sm' | 'md';
+}
+export declare const RadioGroup: <T extends string>(props: RadioGroupProps<T>) => import("react/jsx-runtime").JSX.Element;
+interface RadioProps extends RadioOption<string> {
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    required?: boolean;
+}
+export declare const Radio: ({ value, label, size, disabled, required }: RadioProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Scrollable/ImitateScroll.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    children: React.ReactNode;
+    thumbClassName: string;
+    thumbColor?: string;
+    trackWidth?: number;
+    thumbMargin?: number;
+    scrollableClassName?: string;
+}
+declare const ImitateScroll: ({ children, thumbClassName, scrollableClassName, thumbMargin, trackWidth }: Props) => import("react/jsx-runtime").JSX.Element;
+export { ImitateScroll };

package/dist/types/Scrollable/index.d.ts

@@ -0,0 +1,33 @@
+interface OuterImplementation {
+    implementation: 'outer';
+    shadowPadding?: number;
+    scrollbarWidth: number;
+    noneCorrect?: boolean;
+}
+interface EdgeImplementation {
+    implementation: 'edge';
+    scrollbarWidth: number;
+    padding: number;
+}
+interface InnerImplementation {
+    implementation: 'inner';
+    padding: number;
+}
+interface ScrollableProps {
+    heightAuto?: boolean;
+    scrollX?: boolean;
+    scrollY?: boolean;
+    interactionKind?: 'static' | 'hover';
+    thumbPos?: 'center' | 'border';
+    thumbPadding?: number;
+    thumbColor?: string;
+    onWheel?: React.WheelEventHandler<HTMLDivElement>;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    maxHeight?: number;
+    children: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+type Implementation = InnerImplementation | OuterImplementation | EdgeImplementation;
+declare const Scrollable: import('react').ForwardRefExoticComponent<(ScrollableProps & Implementation) & import('react').RefAttributes<HTMLDivElement>>;
+export { Scrollable };

package/dist/types/Select/SelectInput.d.ts

@@ -0,0 +1,14 @@
+export interface SelectFormProps extends React.HTMLAttributes<HTMLDivElement> {
+    required?: boolean;
+    disabled?: boolean;
+    className?: string;
+    leftElement?: React.ReactNode;
+    placeholder?: string;
+    value?: string | number;
+    size?: 'sm' | 'md' | 'lg';
+    fill?: boolean;
+    clearButton?: boolean;
+    clearButtonIcon?: boolean;
+    onClear?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+export declare const SelectInput: import('react').ForwardRefExoticComponent<SelectFormProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/Select/index.d.ts

@@ -0,0 +1,15 @@
+import { FormProps } from '../Form';
+import { Option } from '../types';
+interface SelectProps<T> extends Omit<FormProps, 'value' | 'onChange' | 'rightElement'> {
+    options: Option<T>[];
+    onChange: (event: T | null) => void;
+    placeholder?: string;
+    clearButton?: boolean;
+    clearButtonIcon?: boolean;
+    value: T | null;
+    children?: React.ReactNode;
+    minimalOptions?: boolean;
+    matchTarget?: 'width' | 'min-width';
+}
+export declare const Select: <T>(props: SelectProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/SelectTags/index.d.ts

@@ -0,0 +1,15 @@
+import { Option } from '../types';
+export interface SelectTagsProps<T> {
+    options: Option<T>[];
+    onChange: (event: T[]) => void;
+    placeholder?: string;
+    value: T[];
+    children?: React.ReactNode;
+    disabled?: boolean;
+    readOnly?: boolean;
+    closeAfterSelect?: boolean;
+    emptyText?: string;
+    size?: 'sm' | 'md' | 'lg';
+    fill?: boolean;
+}
+export declare const SelectTags: <T extends string | number>(props: SelectTagsProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/Spinner/index.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    size?: number;
+    width?: number;
+    color?: string;
+    className?: string;
+}
+export declare const Spinner: ({ size, className, width, color }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Stepper/index.d.ts

@@ -0,0 +1,8 @@
+import { StepperInputOptions } from '../__hooks/use-stepper-input';
+interface StepperInputProps extends StepperInputOptions {
+    buttons?: boolean;
+    placeholder?: string;
+    inputStyle?: React.CSSProperties;
+}
+export declare const StepperInput: ({ inputStyle, placeholder, buttons, ...options }: StepperInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Switch/index.d.ts

@@ -0,0 +1,10 @@
+export interface SwitchProps {
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    checkedIcon?: React.ReactNode;
+    uncheckedIcon?: React.ReactNode;
+}
+declare const Switch: (props: SwitchProps) => import("react/jsx-runtime").JSX.Element;
+export { Switch };

package/dist/types/Tabs/index.d.ts

@@ -0,0 +1,13 @@
+interface Props {
+    children: React.ReactNode;
+    onChange: (value: string) => void;
+    value: string;
+}
+export declare const Tabs: {
+    ({ children, value, onChange }: Props): import("react/jsx-runtime").JSX.Element;
+    Tab: ({ children, value, ...restProps }: TabProps) => import("react/jsx-runtime").JSX.Element;
+};
+interface TabProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+}
+export {};

package/dist/types/TextArea/index.d.ts

@@ -0,0 +1,7 @@
+interface TextAreaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    grow?: boolean;
+    onResize?: (el: HTMLTextAreaElement) => void;
+    fill?: boolean;
+}
+export declare const TextArea: ({ onResize, grow, value, onChange, disabled, required, rows, fill, ...textAreaProps }: TextAreaProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Toaster/RemoveListener.d.ts

@@ -0,0 +1,3 @@
+export declare const RemoveListener: ({ callback }: {
+    callback?: () => void;
+}) => null;

package/dist/types/Toaster/Toast.d.ts

@@ -0,0 +1,9 @@
+import { ToastOptions } from '.';
+interface ToastProps extends ToastOptions {
+    onRemoved: () => void;
+    onRemoving: () => void;
+    onInitialized: (ref: HTMLLIElement) => void;
+    closeIcon?: React.ReactNode;
+}
+export declare const Toast: (options: ToastProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/Toaster/Viewport.d.ts

@@ -0,0 +1,13 @@
+import { InnerToast } from '.';
+export interface ViewportProps {
+    side?: 'top' | 'bottom';
+    align?: 'center' | 'left' | 'right';
+    gap?: number;
+    swipeThreshold?: number;
+    duration?: number;
+    closeIcon?: React.ReactNode;
+}
+export interface ViewportRef {
+    addToast: (toast: InnerToast) => void;
+}
+export declare const Viewport: import('react').ForwardRefExoticComponent<ViewportProps & import('react').RefAttributes<ViewportRef>>;

package/dist/types/Toaster/index.d.ts

@@ -0,0 +1,15 @@
+import { ViewportProps } from './Viewport';
+export interface ToastOptions {
+    appearance?: 'primary' | 'neutral' | 'positive' | 'negative' | 'warning';
+    icon?: React.ReactNode;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    duration?: number;
+}
+export interface InnerToast extends ToastOptions {
+    id: string;
+}
+export declare const createToaster: (rootProps?: ViewportProps) => {
+    send: (toast: ToastOptions) => void;
+    Viewport: (props?: ViewportProps) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/types/Tooltip/index.d.ts

@@ -0,0 +1,8 @@
+import { Side } from '../Popover';
+interface TooltipProps {
+    children: React.ReactNode;
+    content: React.ReactNode;
+    side?: Side;
+}
+export declare const Tooltip: ({ children, content, side }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/__hooks/use-frooze-closing.d.ts

@@ -0,0 +1,5 @@
+export declare const useFroozeClosing: () => {
+    popoverRef: import('react').RefObject<HTMLDivElement>;
+    handleAnimationEnd: () => void;
+    froozePopoverPosition: () => void;
+};

package/dist/types/__hooks/use-loading.d.ts

@@ -0,0 +1,8 @@
+export interface UseLoadingProps<T = unknown> {
+    onClick: (startLoad: () => void, param: T) => Promise<any>;
+}
+export declare const useLoading: <T = unknown>({ onClick }: UseLoadingProps<T>) => {
+    handleClick: (param: T) => void;
+    isLoading: boolean;
+    isError: boolean;
+};

package/dist/types/__hooks/use-local-storage.d.ts

@@ -0,0 +1 @@
+export declare const useLocalStorage: <T>(token: string, defaultValue: T) => [T, React.Dispatch<React.SetStateAction<T>>];

package/dist/types/__hooks/use-popover-position.d.ts

@@ -0,0 +1,8 @@
+export declare const usePopoverLeftValue: () => {
+    popoverRef: import('react').RefObject<HTMLDivElement>;
+    getLeftValue: () => string;
+};
+export declare const useButtonWidth: () => {
+    buttonRef: import('react').RefObject<HTMLButtonElement>;
+    getWidthValue: () => string;
+};

package/dist/types/__hooks/use-previos.d.ts

@@ -0,0 +1,2 @@
+export declare const usePrevious: <T>(value: T) => T | undefined;
+export declare const usePreviousChanged: <T>(value: T) => T | undefined;

package/dist/types/__hooks/use-resize.d.ts

@@ -0,0 +1,3 @@
+type ResizeText = [React.RefObject<HTMLTextAreaElement>, () => void];
+declare const useResizeTextarea: (onResize: ((el: HTMLTextAreaElement) => void) | undefined, grow: boolean) => ResizeText;
+export { useResizeTextarea };

package/dist/types/__hooks/use-scrollbox.d.ts

@@ -0,0 +1,7 @@
+interface UseScrollListControllerReturn {
+    scrollBoxRef: React.RefObject<HTMLDivElement>;
+    optionsWrapperRef: React.RefObject<HTMLDivElement>;
+    scrollToElement: (index: number, center?: boolean) => void;
+}
+export declare const useScrollListController: () => UseScrollListControllerReturn;
+export {};

package/dist/types/__hooks/use-stepper-input.d.ts

@@ -0,0 +1,13 @@
+export interface StepperInputOptions {
+    value: number;
+    onChange: (value: number) => void;
+    step: number;
+    minValue?: number;
+}
+export declare const useStepperInput: ({ minValue, value, onChange, step }: StepperInputOptions) => {
+    inputRef: import('react').RefObject<HTMLInputElement>;
+    value: string;
+    increment: () => void;
+    decrement: () => void;
+    handleChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+};

package/dist/types/__hooks/use-update.d.ts

@@ -0,0 +1 @@
+export declare const useLayoutAndUpdate: (callback: () => void, deps?: React.DependencyList | undefined) => void;

package/dist/types/__hooks/useCalendar.d.ts

@@ -0,0 +1,17 @@
+import { CalendarProps } from '../DatePicker/Calendar';
+export interface UseCalendarDependencies extends Pick<CalendarProps, 'minDateTime' | 'maxDateTime' | 'shouldDisableDate' | 'disableFuture' | 'disablePast'> {
+    disablePast?: boolean;
+    disableFuture?: boolean;
+    minDateTime?: Date;
+    maxDateTime?: Date;
+    value?: Date | null;
+}
+export declare const useCalendar: ({ value, disablePast, disableFuture, shouldDisableDate, minDateTime, maxDateTime }: UseCalendarDependencies) => {
+    viewDate: Date;
+    setViewDate: import('react').Dispatch<import('react').SetStateAction<Date>>;
+    setPrevMonth: () => void;
+    setNextMonth: () => void;
+    isDayDisabled: (day: Date, withTime?: boolean) => boolean;
+    isMonthDisabled: (month: number, year?: number) => boolean;
+    isYearDisabled: (year: number) => boolean;
+};