@vertesia/ui 0.55.0 → 0.57.0

package/lib/types/core/components/Avatar.d.ts

@@ -0,0 +1,15 @@
+interface AvatarProps {
+    shape?: "circle" | "rect";
+    src?: string;
+    name?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    color?: string;
+    className?: string;
+}
+export declare function Avatar({ size, src, name, shape, color, className }: AvatarProps): import("react/jsx-runtime").JSX.Element;
+interface SvgAvatarProps extends Omit<AvatarProps, 'src' | 'name'> {
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare function SvgAvatar({ size, shape, color, className, children }: SvgAvatarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Badge.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "attention" | "success" | "info" | "done" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface BaseBadgeProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
+    children: React.ReactNode;
+    onClick?: () => void;
+}
+export declare function Badge({ className, variant, children, onClick, ...props }: BaseBadgeProps): import("react/jsx-runtime").JSX.Element;
+declare const dotBadgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "attention" | "success" | "info" | "done" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface DotBadgeProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof dotBadgeVariants> {
+    children?: React.ReactNode;
+    dotClassName?: string;
+}
+export declare function DotBadge({ variant, className, dotClassName, // New prop for dot-specific classes
+children, ...props }: DotBadgeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Button.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export interface ButtonProps {
+    isLoading?: boolean;
+    isDisabled?: boolean;
+    variant?: "primary" | "secondary" | "soft" | "ghost" | "unstyled";
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    children: React.ReactNode | React.ReactNode[];
+    onClick?: (ev: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    type?: "button" | "submit" | "reset";
+    title?: string;
+    className?: string;
+}
+export declare function Button({ title, className, type, children, size, onClick, variant, isLoading, isDisabled }: ButtonProps): import("react/jsx-runtime").JSX.Element;

package/lib/types/core/components/Center.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+interface CenterProps {
+    children: ReactNode | ReactNode[];
+    className?: string;
+}
+export declare function Center({ className, children }: CenterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/ComboBox.d.ts

@@ -0,0 +1,123 @@
+import React, { ReactNode } from 'react';
+import { AlignType, PopupController } from "./popup/index";
+export declare abstract class OptionAdapter<T> {
+    abstract valueOf(item: T): string;
+    abstract idOf(item: T): string;
+    filter(items: T[], text: string): T[];
+    renderOption(item: T): ReactNode;
+    findById(items: T[], id: string): T | undefined;
+    createItem(_value: string): T | null;
+}
+export declare class StringOptionAdapter extends OptionAdapter<string> {
+    valueOf(item: string): string;
+    idOf(item: string): string;
+    static instance: StringOptionAdapter;
+}
+export declare class StringOptionAdapterWithCreate extends StringOptionAdapter {
+    createItem(value: string): string;
+    static instance: StringOptionAdapterWithCreate;
+}
+export interface ComboBoxLayoutProps<T> {
+    buttonRight?: number;
+    buttonWidth?: number;
+    maxMenuHeight?: number;
+    menuClass?: string;
+    inputClass?: string;
+    optionClass?: string;
+    Input?: React.ComponentType<ComboInputProps<T>>;
+    Menu?: React.ComponentType<ComboMenuProps<T>>;
+    Toggle?: React.ComponentType<ComboToggleProps<T>> | null;
+}
+export type ComboBoxLayout<T> = Required<ComboBoxLayoutProps<T>>;
+export declare function getDefaultComboBoxLayout<T>(fullWidth?: boolean, unstyledInput?: boolean): ComboBoxLayout<T>;
+export interface ComboBoxApi<T> {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    inputValue: string;
+    selectedItem: T | null;
+    setInputValue: (value: string) => void;
+    focus: () => void;
+}
+interface ComboBoxProps<T> {
+    items: T[];
+    adapter: OptionAdapter<T>;
+    unstyledInput?: boolean;
+    fullWidth?: boolean;
+    layout?: ComboBoxLayoutProps<T>;
+    placeholder?: string;
+    api?: React.MutableRefObject<ComboBoxApi<T> | null>;
+    value?: T | null;
+    onSelect?: (value: T | null) => void;
+    zIndex?: number;
+    focusOnMount?: boolean;
+    menuGap?: number;
+    menuAlign?: AlignType;
+}
+export declare function ComboBox<T>({ menuAlign, menuGap, focusOnMount, onSelect, value, zIndex, unstyledInput, fullWidth, api, layout: layoutOpts, adapter, items, placeholder }: ComboBoxProps<T>): import("react/jsx-runtime").JSX.Element;
+export interface ComboInputProps<T> {
+    layout: ComboBoxLayout<T>;
+    ctrl: ComboboxController<T>;
+    placeholder?: string;
+    boxRef?: React.RefObject<HTMLDivElement | null>;
+    inputRef?: React.RefObject<HTMLInputElement | null>;
+}
+export interface ComboToggleProps<T> {
+    ctrl: ComboboxController<T>;
+    layout: ComboBoxLayout<T>;
+}
+export interface ComboMenuProps<T> {
+    items: T[];
+    layout: ComboBoxLayout<T>;
+    ctrl: ComboboxController<T>;
+    adapter: OptionAdapter<T>;
+    fillWidth: boolean;
+}
+export interface ComboboxControllerProps<ItemT> {
+    adapter: OptionAdapter<ItemT>;
+    items: ItemT[];
+    value?: ItemT | string | null;
+    popupId: string;
+}
+export declare function useComboboxCtrl<ItemT>(props: ComboboxControllerProps<ItemT>): ComboboxController<ItemT>;
+declare class ComboboxController<ItemT> {
+    private popupId;
+    items: ItemT[];
+    private adapter;
+    onSelect?: (item: ItemT | null) => void;
+    private setState?;
+    private _selectedItem;
+    private _filteredItems;
+    private _inputText;
+    private _highlightedIndex;
+    private _isMenuOpen;
+    popupCtrl?: PopupController;
+    constructor({ adapter, items, value, popupId }: ComboboxControllerProps<ItemT>);
+    withState(setState: (ctrl: ComboboxController<ItemT>) => void): this;
+    private clone;
+    private updateState;
+    get filteredItems(): ItemT[];
+    get selectedItem(): ItemT | null;
+    set selectedItem(item: ItemT | null);
+    get isMenuOpen(): boolean;
+    set inputText(inputText: string);
+    get inputText(): string;
+    set highlightedIndex(index: number | null);
+    get highlightedIndex(): number | null;
+    openMenu(): void;
+    closeMenu(_item?: ItemT | null): void;
+    toggleMenu(): void;
+    private highlightIndex;
+    getMenuProps(): {};
+    getToggleButtonProps(): {
+        onClick: () => void;
+    };
+    getItemProps(item: ItemT, index: number): React.HTMLProps<HTMLLIElement>;
+    getInputProps(): {
+        onClick: () => void;
+        onChange: (ev: React.ChangeEvent<HTMLInputElement>) => void;
+        value: string;
+        onKeyDown: (ev: React.KeyboardEvent<HTMLInputElement>) => void;
+    };
+}
+export {};

package/lib/types/core/components/ConfirmModal.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface ConfirmModalProps {
+    title: string;
+    content: string | React.ReactNode;
+    onConfirm: () => void;
+    onCancel: () => void;
+    isOpen: boolean;
+}
+export declare function ConfirmModal({ title, content, onConfirm, onCancel, isOpen }: ConfirmModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/DeleteModal.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+interface DeleteModalProps {
+    idToDelete?: string;
+    title: string;
+    content: string | ReactNode;
+    setIdToDelete: (id: string | undefined) => void;
+    deleteApi: (id: string) => Promise<any>;
+}
+export declare function DeleteModal({ idToDelete, title, content, setIdToDelete, deleteApi }: DeleteModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Divider.d.ts

@@ -0,0 +1,5 @@
+interface DividerProps {
+    className?: string;
+}
+export declare function Divider({ className }: DividerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Dropdown.d.ts

@@ -0,0 +1,14 @@
+interface DropdownProps {
+    trigger: React.ReactNode;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function Dropdown({ trigger, children }: DropdownProps): import("react/jsx-runtime").JSX.Element;
+interface MenuItemProps {
+    children: React.ReactNode | React.ReactNode[];
+    onClick?: (ev: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    href?: string;
+    closeOnClick?: boolean;
+    isDisabled?: boolean;
+}
+export declare function MenuItem({ children, href, onClick, closeOnClick, isDisabled }: MenuItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/DropdownList.d.ts

@@ -0,0 +1,12 @@
+export interface IListItem {
+    id: string;
+    name: string;
+    description?: string;
+}
+interface DropdownListProps {
+    value: IListItem;
+    items: IListItem[];
+    onChange: (item: IListItem) => void;
+}
+export declare function DropdownList({ items, value, onChange }: DropdownListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/EmptyCollection.d.ts

@@ -0,0 +1,8 @@
+interface EmptyInteractionsProps {
+    buttonLabel: string;
+    title: string;
+    onClick: () => void;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function EmptyCollection({ buttonLabel, title, children, onClick }: EmptyInteractionsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/FileUpload.d.ts

@@ -0,0 +1,28 @@
+import { DragEventHandler, MutableRefObject, ReactNode } from "react";
+interface FileUploadInputProps {
+    onUpload: (files: File[]) => unknown;
+    children: ReactNode | ReactNode[];
+}
+export declare function FileUploadInput({ children, onUpload }: FileUploadInputProps): import("react/jsx-runtime").JSX.Element;
+interface DropZoneProps {
+    onUpload: (files: File[]) => unknown;
+    children: ReactNode | ReactNode[];
+    height?: string;
+    border?: string;
+    borderActiveColor?: string;
+}
+export declare function DropZone({ onUpload }: DropZoneProps): import("react/jsx-runtime").JSX.Element;
+export interface IDropZoneOpts {
+    onUpload: (files: File[]) => unknown;
+    dragOverClass?: string;
+    dropEffect?: "none" | "copy" | "link" | "move";
+}
+export interface IDropZoneProps<T> {
+    onDrop: DragEventHandler<T>;
+    onDragOver: DragEventHandler<T>;
+    onDragEnter: DragEventHandler<T>;
+    onDragLeave: DragEventHandler<T>;
+    ref: MutableRefObject<T | null>;
+}
+export declare function useDropZone<T extends HTMLElement = HTMLDivElement>({ onUpload, dragOverClass, dropEffect, }: IDropZoneOpts): IDropZoneProps<T>;
+export {};

package/lib/types/core/components/Input.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface InputProps extends Omit<React.HTMLProps<HTMLInputElement>, 'ref' | 'onChange' | 'value'> {
+    value?: string;
+    onChange?: (value: string) => void;
+    unstyled?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/lib/types/core/components/InputList.d.ts

@@ -0,0 +1,10 @@
+interface InputListProps {
+    value?: string[];
+    onChange: (value: string[]) => void;
+    className?: string;
+    allowSpaces?: boolean;
+    delimiters?: string;
+    placeholder?: string;
+}
+export declare function InputList({ value, onChange, className, delimiters, placeholder }: InputListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Link.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface LinkProps extends React.HTMLProps<HTMLAnchorElement> {
+    underline?: 'always' | 'hover' | 'none';
+}
+export declare function Link({ underline, className, children, ...others }: LinkProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/MenuList.d.ts

@@ -0,0 +1,13 @@
+import { AnchorHTMLAttributes } from "react";
+interface MenuListProps {
+    children: React.ReactNode | React.ReactNode[];
+    className?: string;
+}
+export declare function MenuList({ className, children }: MenuListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace MenuList {
+    var Item: import("react").ForwardRefExoticComponent<MenuListItemProps & import("react").RefAttributes<HTMLAnchorElement>>;
+}
+interface MenuListItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    current?: boolean;
+}
+export {};

package/lib/types/core/components/MessageBox.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+interface MessageBoxProps {
+    status: 'error' | 'info' | 'warning' | 'success' | 'default' | 'done';
+    icon?: React.ReactNode;
+    title?: string;
+    children: React.ReactNode | React.ReactNode[];
+    className?: string;
+}
+export declare function MessageBox({ icon, status, title, children, className }: MessageBoxProps): import("react/jsx-runtime").JSX.Element;
+export declare function ErrorBox({ title, className, children }: {
+    title: string;
+    className?: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function InfoBox({ title, className, children }: {
+    title: string;
+    className?: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function WarningBox({ title, className, children }: {
+    title: string;
+    className?: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SuccessBox({ title, className, children }: {
+    title: string;
+    className?: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DefaultBox({ title, className, children }: {
+    title: string;
+    className?: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Modal.d.ts

@@ -0,0 +1,29 @@
+interface ModalProps {
+    children: React.ReactNode | React.ReactNode[];
+    isOpen: boolean;
+    onClose: () => void;
+    noCloseButton?: boolean;
+    className?: string;
+    allowOverflow?: boolean;
+    disableCloseOnClickOutside?: boolean;
+}
+export declare function Modal({ className, children, isOpen, onClose, noCloseButton, allowOverflow, disableCloseOnClickOutside, }: ModalProps): import("react/jsx-runtime").JSX.Element;
+interface ModalTitleProps {
+    children: React.ReactNode | React.ReactNode[];
+    showDivider?: boolean;
+}
+export declare function ModalTitle({ children, showDivider }: ModalTitleProps): import("react/jsx-runtime").JSX.Element;
+interface ModalFooterProps {
+    showDivider?: boolean;
+    fill?: boolean;
+    justify?: "start" | "end" | "center" | "space-between" | "space-around" | "space-evenly" | "stretch";
+    className?: string;
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function ModalFooter({ children, className, fill }: ModalFooterProps): import("react/jsx-runtime").JSX.Element;
+interface ModalBodyProps {
+    children: React.ReactNode | React.ReactNode[];
+    className?: string;
+}
+export declare function ModalBody({ children, className }: ModalBodyProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/NumberInput.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+interface NumberInputProps extends Omit<React.HTMLProps<HTMLInputElement>, 'ref' | 'onChange' | 'value'> {
+    value?: number;
+    onChange?: (value: undefined | number, text: string) => void;
+    noScroll?: boolean;
+    noSpinners?: boolean;
+}
+/**
+ * The value of this input is always a number. It can be undefined or NaN. If NaN the input value will not be updated with the NaN one.
+ * If undefined the input will be updated to be empty.
+ * The onChange callback is called whenever the value changes. If the input cannot be parsed as a number
+ * it will be returned as NaN.
+ */
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
+export { NumberInput };

package/lib/types/core/components/Portal.d.ts

@@ -0,0 +1,5 @@
+interface PortalProps {
+    children: React.ReactNode | React.ReactNode[];
+}
+export declare function Portal({ children }: PortalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/RadioGroup.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from "react";
+export declare abstract class RadioOptionAdapter<T> {
+    abstract labelOf(item: T): string;
+    abstract idOf(item: T): string;
+    renderOption(item: T): ReactNode;
+    findById(items: T[], id: string): T | undefined;
+}
+interface RadioGroupProps<OptionT> {
+    checkIcon?: React.ComponentType<CheckIconProps>;
+    options: OptionT[];
+    cols?: `grid-cols-${number}`;
+    gap?: `gap-${number}`;
+    value?: OptionT;
+    onChange: (value: OptionT) => void;
+    adapter: RadioOptionAdapter<OptionT>;
+    checkColor?: string;
+}
+export declare function RadioGroup<OptionT>({ checkColor, cols, gap, value, onChange, options, checkIcon: CheckIcon, adapter }: RadioGroupProps<OptionT>): import("react/jsx-runtime").JSX.Element;
+export interface CheckIconProps {
+    size: number;
+    isChecked: boolean;
+    isHighlighted?: boolean;
+    color?: string;
+}
+export {};

package/lib/types/core/components/SelectBox.d.ts

@@ -0,0 +1,35 @@
+import { ComponentType, ReactNode } from "react";
+type OnChangeClearableSelectFn<T> = (option: T | undefined) => void;
+type OnChangeNonClearableSelectFn<T> = (option: T) => void;
+interface SelectBoxBaseProps<T> {
+    options: T[] | undefined;
+    optionLabel?: (option: T) => ReactNode;
+    value?: T;
+    onChange: OnChangeNonClearableSelectFn<T>;
+    className?: string;
+    by?: (keyof T & string) | ((a: T, z: T) => boolean);
+    placeholder?: ReactNode;
+    addNew?: () => void;
+    addNewLabel?: string;
+    disabled?: boolean;
+    isClearable?: false;
+    showFilter?: boolean | string;
+    filterBy?: string | ((o: T) => string);
+    ClearIcon?: ComponentType<any>;
+    clearTitle?: string | undefined;
+    label?: string | undefined;
+}
+interface ClearableSelectBoxProps<T> extends Omit<SelectBoxBaseProps<T>, 'isClearable' | 'onChange'> {
+    onChange: OnChangeClearableSelectFn<T>;
+    isClearable: true;
+}
+type SelectBoxProps<T> = ClearableSelectBoxProps<T> | SelectBoxBaseProps<T>;
+export declare function SelectBox<T>({ clearTitle, ClearIcon, showFilter, filterBy, isClearable, disabled, by, options, value, onChange, className, addNew, addNewLabel, placeholder, optionLabel, label }: SelectBoxProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function ListOption<T>({ option, optionLabel, onClick, className }: {
+    option: T;
+    optionLabel: (option: T) => ReactNode;
+    onClick?: () => void;
+    value?: T;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/SelectList.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+export interface OptionLayout {
+    label?: ReactNode;
+    check?: ReactNode;
+    reverse?: boolean;
+    className?: string;
+}
+export interface SelectListProps<T> {
+    value?: T;
+    options: T[];
+    onChange: (value: T) => void;
+    className?: string;
+    by?: (keyof T & string) | ((o1: T, o2: T) => boolean);
+    optionLayout?: (opt: T, selected: boolean) => OptionLayout;
+    noCheck?: boolean;
+}
+export declare function SelectList<T>({ value, options, onChange, className, optionLayout, by, noCheck }: SelectListProps<T>): import("react/jsx-runtime").JSX.Element;

package/lib/types/core/components/SelectStack.d.ts

@@ -0,0 +1,12 @@
+interface SelectStackOption {
+    id: string;
+    label: string;
+    description?: React.ReactNode;
+}
+interface SelectStackProps {
+    onSelect: (option: SelectStackOption) => void;
+    selected?: SelectStackOption;
+    options: SelectStackOption[];
+}
+export declare function SelectStack({ onSelect, selected, options }: SelectStackProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/SidePanel.d.ts

@@ -0,0 +1,8 @@
+interface SidePanelProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: React.ReactNode;
+    title?: string;
+}
+export declare function SidePanel({ isOpen, title, onClose, children }: SidePanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Spinner.d.ts

@@ -0,0 +1,6 @@
+interface SpinnerProps {
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    className?: string;
+}
+export declare function Spinner({ size, className }: SpinnerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Switch.d.ts

@@ -0,0 +1,9 @@
+interface SwitchProps {
+    size?: 'sm' | 'md' | 'lg';
+    value: boolean;
+    onChange: (value: boolean) => void;
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare function Switch({ value, onChange, size, children, className }: SwitchProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/Textarea.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface TextareaProps extends Omit<React.HTMLProps<HTMLTextAreaElement>, 'ref' | 'onChange'> {
+    onChange: (value: string) => void;
+    unstyled?: boolean;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/lib/types/core/components/index.d.ts

@@ -0,0 +1,37 @@
+export * from "./Avatar.js";
+export * from "./Badge.js";
+export * from "./Center.js";
+export * from "./ComboBox.js";
+export * from "./ConfirmModal.js";
+export * from "./DeleteModal.js";
+export * from "./Divider.js";
+export * from "./SidePanel.js";
+export * from "./Dropdown.js";
+export * from "./DropdownList.js";
+export * from "./EmptyCollection.js";
+export * from "./FileUpload.js";
+export * from "./Input.js";
+export * from "./InputList.js";
+export * from "./Link.js";
+export * from "./MenuList.js";
+export * from "./MessageBox.js";
+export * from "./Modal.js";
+export * from "./NumberInput.js";
+export * from "./popup/index.js";
+export * from "./Portal.js";
+export * from "./RadioGroup.js";
+export * from "./SelectBox.js";
+export * from "./SelectList.js";
+export * from "./SelectStack.js";
+export * from "./Spinner.js";
+export * from "./styles.js";
+export * from "./Switch.js";
+export * from "./table/index.js";
+export * from "./tabs/index.js";
+export * from "./Textarea.js";
+export * from "./toast/index.js";
+export * from "./shadcn/index.js";
+export type HeroIcon = React.ForwardRefExoticComponent<Omit<React.SVGProps<SVGSVGElement>, "ref"> & {
+    title?: string | undefined;
+    titleId?: string | undefined;
+} & React.RefAttributes<SVGSVGElement>>;

package/lib/types/core/components/libs/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/lib/types/core/components/libs/visuallyHidden.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface VisuallyHiddenProps {
+    children: React.ReactNode;
+}
+export declare function VisuallyHidden({ children }: VisuallyHiddenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/core/components/popup/Popup.d.ts

@@ -0,0 +1,25 @@
+import { MutableRefObject, ReactNode } from "react";
+import { PopupController, PopupControllerOptions } from "./PopupController";
+import { Constraints } from "./position";
+export declare function usePopupController(): PopupController;
+interface DOMPopupProps extends Omit<PopupControllerOptions, 'anchor' | 'popup' | 'root'> {
+    isOpen: boolean;
+    constraints: Constraints;
+    anchor: HTMLElement;
+    root?: HTMLElement;
+    zIndex?: number;
+    position?: "absolute" | "fixed";
+    onClose?: () => void;
+    onOpen?: () => void;
+    className?: string;
+    id?: string;
+    children: ReactNode | ReactNode[];
+    ctrlRef?: MutableRefObject<PopupController | undefined>;
+}
+export declare function DOMPopup({ ctrlRef, id, constraints, isOpen, children, className, onClose, zIndex, position, ...props }: DOMPopupProps): import("react/jsx-runtime").JSX.Element;
+export interface PopupProps extends Omit<DOMPopupProps, 'anchor' | 'root'> {
+    anchor: React.RefObject<HTMLElement | null | undefined>;
+    root?: React.RefObject<HTMLElement | null | undefined>;
+}
+export declare function Popup({ anchor, root, children, ...others }: PopupProps): import("react/jsx-runtime").JSX.Element | null;
+export {};