pentatrion-design 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1110 @@
+import { T as ThemeColor, M as Message, a as MessageOptions } from './types.d-DlHa_IaW.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import react__default, { ComponentProps, ReactNode, ComponentPropsWithoutRef, ComponentPropsWithRef, ElementType, Ref, ReactElement, HTMLProps, ButtonHTMLAttributes, Dispatch, SetStateAction, MutableRefObject, RefObject, useEffect } from 'react';
+import { Geometry, BBox } from 'geojson';
+import * as _floating_ui_react from '@floating-ui/react';
+import { Placement, useInteractions } from '@floating-ui/react';
+import * as _floating_ui_react_dom from '@floating-ui/react-dom';
+import { ItemInterface, ReactSortableProps } from 'react-sortablejs';
+import * as tailwindcss_types_config from 'tailwindcss/types/config';
+
+interface Props$H extends ComponentProps<"table"> {
+    children: ReactNode;
+}
+declare function Table$6({ children, ...props }: Props$H): react_jsx_runtime.JSX.Element;
+
+interface Props$G {
+    children: ReactNode;
+}
+declare function Table$5({ children, ...props }: Props$G): react_jsx_runtime.JSX.Element;
+
+interface Props$F extends ComponentProps<"td"> {
+    children: ReactNode;
+    label?: ReactNode | string;
+}
+declare function Table$4({ children, className, label, ...props }: Props$F): react_jsx_runtime.JSX.Element;
+
+interface Props$E extends ComponentProps<"thead"> {
+    children: ReactNode;
+}
+declare function Table$3({ children, className, ...props }: Props$E): react_jsx_runtime.JSX.Element;
+
+interface Props$D extends ComponentProps<"th"> {
+    children: ReactNode;
+}
+declare function Table$2({ children, className, ...props }: Props$D): react_jsx_runtime.JSX.Element;
+
+interface Props$C extends ComponentProps<"tr"> {
+    children: ReactNode;
+}
+declare function Table$1({ children, className, ...props }: Props$C): react_jsx_runtime.JSX.Element;
+
+interface Props$B extends ComponentProps<"tfoot"> {
+    children: ReactNode;
+}
+declare function Table({ children, ...props }: Props$B): react_jsx_runtime.JSX.Element;
+
+declare const cardConfig: {
+    item: string;
+    group: string;
+};
+
+interface Props$A {
+    children: ReactNode;
+    className?: string;
+}
+declare function Code({ children, className }: Props$A): react_jsx_runtime.JSX.Element;
+
+interface Tab {
+    id: string | number;
+    title: ReactNode;
+    content?: ReactNode;
+}
+interface Props$z {
+    tabs?: Tab[];
+    value: number | string;
+    /**
+     * Will make tabs stick to the top of the container when overflowing
+     */
+    stickyTabs?: boolean;
+    /**
+     * Tabs will take the maximum width and divide equally
+     */
+    fullWidth?: boolean;
+    onChange: (id: number | string) => void;
+    children?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    listClassName?: string;
+}
+declare function Tabs({ className, listClassName, contentClassName, tabs, value, onChange, fullWidth, stickyTabs, children, }: Props$z): react_jsx_runtime.JSX.Element;
+
+interface Props$y {
+    color?: ThemeColor;
+    children?: ReactNode;
+    className?: string;
+}
+declare function Alert({ color, children, className }: Props$y): react_jsx_runtime.JSX.Element;
+
+interface Props$x extends ComponentPropsWithoutRef<"div"> {
+    horizontal?: boolean;
+}
+declare function Scroll({ horizontal, className, children, ...rest }: Props$x): react_jsx_runtime.JSX.Element;
+
+interface Props$w extends ComponentPropsWithoutRef<"svg"> {
+    size?: "small" | "medium" | "large";
+    color?: ThemeColor;
+}
+declare function Loader({ size, color, className, ...rest }: Props$w): react_jsx_runtime.JSX.Element;
+
+interface Props$v {
+    children: ReactNode;
+}
+declare const Portal: ({ children }: Props$v) => react.ReactPortal;
+
+interface Props$u {
+    children: ReactNode;
+    className?: string;
+    tooltip?: string;
+    url?: string;
+    color?: ThemeColor;
+    onClick?: () => void;
+    onRemove?: () => void;
+}
+declare function Badge({ children, className, onRemove, onClick, tooltip, url, color, }: Props$u): react_jsx_runtime.JSX.Element;
+
+interface Props$t {
+    value: string | undefined;
+    indices: readonly [number, number][];
+    minLength?: number;
+}
+declare function Hightlight({ value, indices, minLength }: Props$t): string | react_jsx_runtime.JSX.Element | undefined;
+
+interface InputProps extends Omit<ComponentPropsWithRef<"input">, "prefix"> {
+    variant?: "normal" | "ghost";
+    disabled?: boolean;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    color?: ThemeColor;
+}
+declare const inputConfig: {
+    container: string;
+    input: string;
+};
+declare const Input: (props: InputProps & react.RefAttributes<HTMLInputElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+type Merge<T, U> = Omit<T, keyof U> & U;
+type PropsWithAs<P, T extends React.ElementType> = P & { as?: T };
+type PolymorphicPropsWithRef<P, T extends React.ElementType> = Merge<
+  T extends keyof JSX.IntrinsicElements
+    ? React.PropsWithRef<JSX.IntrinsicElements[T]>
+    : React.ComponentPropsWithRef<T>,
+  PropsWithAs<P, T>
+>;
+
+declare global {
+  interface GlobalEventHandlersEventMap {
+    "maplibre-contextmenu": CustomEvent;
+  }
+}
+
+declare module "react" {
+  interface CSSProperties {
+    [key: `--${string}`]: string | number;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  function forwardRef<T, P = {}>(
+    render: (props: P, ref: React.Ref<T>) => React.ReactElement | null,
+  ): (props: P & React.RefAttributes<T>) => React.ReactElement | null;
+}
+
+interface InputFieldOwnProps {
+    label?: ReactNode;
+    hint?: ReactNode;
+    help?: ReactNode;
+    error?: ReactNode | boolean;
+    warning?: ReactNode | boolean;
+}
+declare const defaultElement: (props: InputProps & react.RefAttributes<HTMLInputElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+type Props$s<E extends ElementType> = PolymorphicPropsWithRef<InputFieldOwnProps, E>;
+declare const InputField: <E extends ElementType = typeof defaultElement>(props: Props$s<E>) => ReactNode;
+
+interface Props$r {
+    name: string;
+    position: "top" | "bottom" | "left" | "right";
+    initialValue?: number;
+}
+declare function ResizeArea({ name, position, initialValue }: Props$r): react_jsx_runtime.JSX.Element;
+
+type SnackProps = Partial<Message> & {
+    onRemove?: () => void;
+};
+declare function Snack({ expiration, content, color, withLoader, canClose, onRemove, }: SnackProps): react_jsx_runtime.JSX.Element;
+
+interface Props$q extends ComponentPropsWithRef<"a"> {
+    children: ReactNode;
+    ghost?: boolean;
+}
+declare const Href: (props: Props$q & react.RefAttributes<HTMLAnchorElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+type OptionLike = Option | GeoOption;
+
+type Option = {
+  type?: "Option";
+  value: string;
+  label: string;
+  sourceId?: string | number;
+};
+
+type NoDataOption = {
+  id: string;
+  type: "nodata";
+};
+
+/** For compatibility with OptionLike. get original types from pentatrion-geo */
+type GeoOption<G extends Geometry | null = Geometry, T extends string = string> = {
+  id: string;
+  type: "Feature";
+  properties: FeatureProperties<T>;
+  geometry: G;
+  bbox?: BBox | undefined;
+};
+
+type FeatureProperties<T extends string = string> = {
+  id: string;
+
+  /** computed name + short context for input string */
+  label: string;
+  name: string;
+  context: string | null;
+  score: number;
+  type: T;
+  originalProperties?: any;
+};
+
+type Props$p<O extends Option> = O;
+declare function SelectOption<O extends Option>({ label }: Props$p<O>): react_jsx_runtime.JSX.Element;
+
+type SelectSelectionProps<O extends Option> = O & {
+    multiple?: boolean;
+};
+declare function SelectSelection<O extends Option>({ label, multiple, }: SelectSelectionProps<O>): react_jsx_runtime.JSX.Element;
+
+type SelectValue = number | string | null;
+type ChangeEventLike = {
+    target: {
+        value: SelectValue;
+    };
+};
+type Props$o<O extends Option = Option> = {
+    disabled?: boolean;
+    variant?: "normal" | "ghost";
+    showArrow?: boolean;
+    selectionClassName?: string;
+    width?: number | string;
+    floatingMinWidth?: number;
+    placement?: Placement;
+    options: O[];
+    placeholder?: string;
+    getSearchableValue?: (matchReg: RegExp, option: O) => string;
+    searchable?: boolean;
+    required?: boolean;
+    selectOptionComponent?: (props: O) => ReactNode;
+    selectSelectionComponent?: (props: SelectSelectionProps<O>) => ReactNode;
+    value?: SelectValue;
+    onChange?: ((e: ChangeEventLike) => void) | null;
+    zIndex?: number;
+};
+declare const Select: <O extends Option>(p: Props$o<O> & {
+    ref?: Ref<HTMLDivElement>;
+}) => ReactElement;
+
+interface SelectContext {
+    activeIndex: number | null;
+    selectedIndex: number | null;
+    getItemProps: ReturnType<typeof useInteractions>["getItemProps"];
+    handleSelect: (index: number | null) => void;
+}
+declare const SelectContext: react.Context<SelectContext | null>;
+declare function useSelect(): SelectContext;
+
+type AutocompleteOptionProps<O extends OptionLike> = O;
+declare function AutocompleteOption<O extends OptionLike>(props: AutocompleteOptionProps<O>): react_jsx_runtime.JSX.Element;
+declare const _default$2: react.MemoExoticComponent<typeof AutocompleteOption>;
+
+interface AutocompleteProps<O extends OptionLike = Option> {
+    className?: string;
+    icon?: boolean | ReactNode;
+    color?: ThemeColor;
+    /**
+     * render suffix only if selection
+     * ex: add contextuel buttons associated to selection
+     */
+    selectionSuffix?: ReactNode;
+    /**
+     * render suffix only if selection and searchValue is empty
+     */
+    noSearchSuffix?: ReactNode;
+    placement?: Placement;
+    placeholder?: string;
+    /**
+     * search string used as value for <input>
+     */
+    searchValue: string;
+    /**
+     * change handler when typing in the input
+     * or when clicking on an option (the label value is passed)
+     */
+    onChangeSearchValue: (value: string, selectionLabel: boolean) => void;
+    selection?: O | null;
+    /**
+     * select handler for a selection from the autocomplete's dropdown
+     * the option object is passed when clicking on an option
+     * null value is passed when typing a new character in the input search.
+     */
+    onChangeSelection: (option: O | null) => void;
+    options: O[];
+    autocompleteOptionComponent?: (props: AutocompleteOptionProps<O>) => ReactNode;
+    loading?: boolean;
+    clearSearchButton?: boolean;
+    selectOnFocus?: boolean;
+}
+declare const _default$1: <O extends OptionLike = Option>(props: AutocompleteProps<O> & react.RefAttributes<HTMLInputElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$n<O extends OptionLike = Option> extends Pick<AutocompleteProps<O>, "className" | "icon" | "color" | "placement" | "placeholder" | "selection" | "onChangeSelection" | "autocompleteOptionComponent" | "options" | "selection"> {
+}
+declare function SimpleAutocomplete<O extends OptionLike = Option>({ options, selection, onChangeSelection, ...rest }: Props$n<O>): react_jsx_runtime.JSX.Element;
+
+interface Props$m<O extends OptionLike = Option> extends Pick<AutocompleteProps<O>, "className" | "icon" | "color" | "selectionSuffix" | "noSearchSuffix" | "placement" | "placeholder" | "selection" | "onChangeSelection" | "autocompleteOptionComponent" | "loading" | "clearSearchButton"> {
+    onChangeSearchValueCallback: (searchValue: string) => Promise<O[]>;
+    debounce?: number;
+}
+declare function LazyAutocomplete<O extends OptionLike = Option>({ onChangeSearchValueCallback, debounce, selection, onChangeSelection, ...rest }: Props$m<O>): react_jsx_runtime.JSX.Element;
+
+interface AutocompleteContext {
+    activeIndex: number | null;
+    selection: OptionLike | null;
+    getItemProps: ReturnType<typeof useInteractions>["getItemProps"];
+    handleSelect: (index: number | null) => void;
+}
+declare const AutocompleteContext: react.Context<AutocompleteContext | null>;
+declare function useAutocomplete(): AutocompleteContext;
+
+declare function getOptionLabel(option: OptionLike): string;
+declare function getOptionValue(option: OptionLike): string;
+
+interface ButtonProps extends ComponentPropsWithRef<"button"> {
+    withRipple?: boolean;
+    variant?: "contained" | "light" | "outlined" | "text" | "ghost";
+    size?: "small" | "medium" | "large" | "custom";
+    color?: ThemeColor;
+    children?: React.ReactNode;
+    /**
+     * undefined: hidden
+     * false: invisible
+     * true: visible
+     */
+    loading?: boolean;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    focusable?: boolean;
+    /**
+     * For a selected item inside a group.
+     */
+    selected?: boolean;
+    icon?: boolean;
+}
+declare const buttonVariants: {
+    size(icon: boolean, size: "small" | "medium" | "large" | "custom"): string | false;
+    variant: {
+        contained(color: ThemeColor): string;
+        light(color: ThemeColor): string;
+        outlined(color: ThemeColor): string;
+        text(color: ThemeColor): string;
+        ghost(color: ThemeColor): string;
+    };
+};
+declare const Button: (props: ButtonProps & react.RefAttributes<HTMLButtonElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$l extends ComponentProps<"div"> {
+    children: ReactNode;
+    direction?: "horizontal" | "vertical";
+}
+declare function ButtonGroup({ children, className, direction }: Props$l): react_jsx_runtime.JSX.Element;
+
+interface Props$k extends ComponentPropsWithRef<"div"> {
+    children: ReactElement[] | ReactElement;
+    eventName?: "contextmenu" | "maplibre-contextmenu";
+}
+declare function ContextMenu({ children, style, eventName }: Props$k): react_jsx_runtime.JSX.Element;
+
+type ContextMenuItemMouseEvent = react__default.MouseEvent<HTMLButtonElement> | MouseEvent | CustomEvent | null;
+interface ContextMenuItemProps extends Omit<ComponentPropsWithRef<"button">, "onClick"> {
+    label: string;
+    disabled?: boolean;
+    icon?: ReactNode;
+    onClick?: (e: ContextMenuItemMouseEvent) => void;
+}
+declare const ContextMenuItem: (props: ContextMenuItemProps & react__default.RefAttributes<HTMLButtonElement>) => react__default.ReactElement<any, string | react__default.JSXElementConstructor<any>> | null;
+
+interface Props$j extends ComponentProps<"div"> {
+    color?: ThemeColor;
+    placement?: Placement;
+    children: ReactNode;
+}
+declare const dialogVariants: {
+    color(color?: ThemeColor): string;
+};
+declare function Dialog({ placement, color, children, className, ...rest }: Props$j): react_jsx_runtime.JSX.Element;
+
+interface DropdownMenuOptions {
+  initialOpen?: boolean;
+  placement?: Placement;
+  open?: boolean;
+  onOpen?: (open: boolean) => void;
+  color?: ThemeColor | "default";
+  modal?: boolean;
+}
+
+interface Props$i extends DropdownMenuOptions {
+    children: ReactNode;
+}
+declare function DropdownMenu({ children, ...options }: Props$i): react_jsx_runtime.JSX.Element;
+
+declare const DropdownMenuContent: (props: react.ClassAttributes<HTMLDivElement> & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$h extends HTMLProps<HTMLElement> {
+    asChild?: boolean;
+}
+declare const DropdownMenuTrigger: (props: Props$h & react.RefAttributes<HTMLElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+declare function useDropdownMenu({ initialOpen, placement, open: controlledOpen, onOpen: setControlledOpen, color, modal, }: DropdownMenuOptions): {
+    elementsRef: react.MutableRefObject<(HTMLElement | null)[]>;
+    labelsRef: react.MutableRefObject<(string | null)[]>;
+    color: ThemeColor | "default";
+    modal: boolean;
+    activeIndex: number | null;
+    handleSelect: () => void;
+    placement: _floating_ui_react.Placement;
+    strategy: _floating_ui_react.Strategy;
+    middlewareData: _floating_ui_react.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react.Placement;
+        strategy: _floating_ui_react.Strategy;
+        middlewareData: _floating_ui_react.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+
+type ContextType$3 = ReturnType<typeof useDropdownMenu> | null;
+declare const DropdownMenuContext: react.Context<ContextType$3>;
+declare function useDropdownMenuContext(): {
+    elementsRef: react.MutableRefObject<(HTMLElement | null)[]>;
+    labelsRef: react.MutableRefObject<(string | null)[]>;
+    color: ThemeColor | "default";
+    modal: boolean;
+    activeIndex: number | null;
+    handleSelect: () => void;
+    placement: _floating_ui_react_dom.Placement;
+    strategy: _floating_ui_react_dom.Strategy;
+    middlewareData: _floating_ui_react_dom.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react_dom.Placement;
+        strategy: _floating_ui_react_dom.Strategy;
+        middlewareData: _floating_ui_react_dom.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+
+interface Props$g extends ComponentProps<"button"> {
+    children: ReactNode;
+}
+declare function DropdownMenuItem({ children, onClick, ...rest }: Props$g): react_jsx_runtime.JSX.Element;
+
+interface Props$f extends ButtonProps {
+    label: string;
+    triggerComponent: typeof Button;
+}
+declare const DropdownMenuNested: (props: Props$f & react.RefAttributes<HTMLButtonElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$e {
+    label: string;
+    disabled?: boolean;
+}
+declare const MenuItem: (props: Props$e & ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$d extends ButtonProps {
+    label?: string;
+    triggerComponent?: typeof Button;
+}
+declare const MenuItemWithChildren: (props: Props$d & react.RefAttributes<HTMLButtonElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$c extends ComponentPropsWithRef<"input"> {
+    indeterminate?: boolean;
+    disabled?: boolean;
+    color?: ThemeColor;
+}
+declare const Checkbox: (props: Props$c & react.RefAttributes<HTMLInputElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$b {
+    value: string | null;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    onChange?: (newValue: string | null) => void;
+    disabled?: boolean;
+    placement?: "inline" | "inline-grid" | "block";
+    className?: string;
+    color?: ThemeColor;
+}
+declare function RadioGroup({ value, options, onChange, placement, disabled, className, color, }: Props$b): react_jsx_runtime.JSX.Element;
+
+interface Props$a extends ComponentPropsWithRef<"input"> {
+    disabled?: boolean;
+    color?: ThemeColor;
+}
+declare const Toggle: (props: Props$a & react.RefAttributes<HTMLInputElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface ModalOptions {
+  initialOpen?: boolean;
+  open?: boolean;
+  onOpen?: (open: boolean) => void;
+  color?: ThemeColor | "default";
+}
+
+interface Props$9 extends ModalOptions {
+    children?: ReactNode;
+}
+declare function Modal({ children, ...options }: Props$9): react_jsx_runtime.JSX.Element;
+
+declare const ModalContent: (props: react.ClassAttributes<HTMLDivElement> & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$8 extends HTMLProps<HTMLElement> {
+    asChild?: boolean;
+}
+declare const ModalTrigger: (props: Props$8 & react.RefAttributes<HTMLElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+declare function useModal({ initialOpen, open: controlledOpen, onOpen: setControlledOpen, color, }?: ModalOptions): {
+    color: ThemeColor | "default";
+    labelId: string | undefined;
+    descriptionId: string | undefined;
+    setLabelId: Dispatch<SetStateAction<string | undefined>>;
+    setDescriptionId: Dispatch<SetStateAction<string | undefined>>;
+    placement: _floating_ui_react.Placement;
+    strategy: _floating_ui_react.Strategy;
+    middlewareData: _floating_ui_react.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react.Placement;
+        strategy: _floating_ui_react.Strategy;
+        middlewareData: _floating_ui_react.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: Dispatch<SetStateAction<boolean>>;
+};
+
+type ContextType$2 = ReturnType<typeof useModal> | null;
+declare const ModalContext: react.Context<ContextType$2>;
+declare function useModalContext(): {
+    color: ThemeColor | "default";
+    labelId: string | undefined;
+    descriptionId: string | undefined;
+    setLabelId: react.Dispatch<react.SetStateAction<string | undefined>>;
+    setDescriptionId: react.Dispatch<react.SetStateAction<string | undefined>>;
+    placement: _floating_ui_react_dom.Placement;
+    strategy: _floating_ui_react_dom.Strategy;
+    middlewareData: _floating_ui_react_dom.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react_dom.Placement;
+        strategy: _floating_ui_react_dom.Strategy;
+        middlewareData: _floating_ui_react_dom.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
+};
+
+interface ModalHeaderProps extends ComponentProps<"h2"> {
+    closeButton?: boolean;
+}
+declare function ModalHeader({ children, className, closeButton, ...props }: ModalHeaderProps): react_jsx_runtime.JSX.Element;
+interface ModalDescriptionProps extends ComponentProps<"div"> {
+    height?: number;
+}
+declare function ModalDescription({ children, className, height, ...props }: ModalDescriptionProps): react_jsx_runtime.JSX.Element;
+declare function ModalFooter({ children, className, ...props }: ComponentProps<"footer">): react_jsx_runtime.JSX.Element;
+
+interface Props$7 {
+    children: ReactNode;
+}
+declare function NotificationsProvider({ children }: Props$7): react_jsx_runtime.JSX.Element;
+
+declare const NotificationsContext: react.Context<{
+    addNotification: (content?: string, { expiration, color, canClose, withLoader, }?: MessageOptions) => string;
+    removeNotification: (id: string) => void;
+    notifyError: (err: unknown) => void;
+}>;
+
+interface PopoverOptions {
+  initialOpen?: boolean;
+  placement?: Placement;
+  open?: boolean;
+  onOpen?: (open: boolean) => void;
+  color?: ThemeColor;
+  modal?: boolean;
+}
+
+interface Props$6 extends PopoverOptions {
+    children: ReactNode;
+}
+declare function Popover({ children, ...options }: Props$6): react_jsx_runtime.JSX.Element;
+
+declare const PopoverContent: (props: react.ClassAttributes<HTMLDivElement> & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$5 extends HTMLProps<HTMLElement> {
+    asChild?: boolean;
+}
+declare const PopoverTrigger: (props: Props$5 & react.RefAttributes<HTMLElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+declare function usePopover({ initialOpen, placement, open: controlledOpen, onOpen: setControlledOpen, color, modal, }: PopoverOptions): {
+    arrowRef: react.RefObject<HTMLDivElement>;
+    color: ThemeColor | undefined;
+    modal: boolean;
+    labelId: string | undefined;
+    descriptionId: string | undefined;
+    setLabelId: react.Dispatch<react.SetStateAction<string | undefined>>;
+    setDescriptionId: react.Dispatch<react.SetStateAction<string | undefined>>;
+    placement: _floating_ui_react.Placement;
+    strategy: _floating_ui_react.Strategy;
+    middlewareData: _floating_ui_react.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react.Placement;
+        strategy: _floating_ui_react.Strategy;
+        middlewareData: _floating_ui_react.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+
+type ContextType$1 = ReturnType<typeof usePopover> | null;
+declare const PopoverContext: react.Context<ContextType$1>;
+declare function usePopoverContext(): {
+    arrowRef: react.RefObject<HTMLDivElement>;
+    color: ThemeColor | undefined;
+    modal: boolean;
+    labelId: string | undefined;
+    descriptionId: string | undefined;
+    setLabelId: react.Dispatch<react.SetStateAction<string | undefined>>;
+    setDescriptionId: react.Dispatch<react.SetStateAction<string | undefined>>;
+    placement: _floating_ui_react_dom.Placement;
+    strategy: _floating_ui_react_dom.Strategy;
+    middlewareData: _floating_ui_react_dom.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react_dom.Placement;
+        strategy: _floating_ui_react_dom.Strategy;
+        middlewareData: _floating_ui_react_dom.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+
+interface PopoverHeaderProps extends ComponentProps<"h2"> {
+    closeButton?: boolean;
+}
+declare function PopoverHeader({ children, closeButton, className, ...props }: PopoverHeaderProps): react_jsx_runtime.JSX.Element;
+declare function PopoverDescription({ children, className, ...props }: ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function PopoverFooter({ children, className, ...props }: ComponentProps<"footer">): react_jsx_runtime.JSX.Element;
+
+interface Props$4 extends ComponentPropsWithoutRef<"li"> {
+    icon?: ReactNode;
+    status?: "done" | "current" | "todo";
+    /** choose center if content height is less than ll-circle height */
+    align?: "start" | "center";
+    markerClassName?: string;
+    contentClassName?: string;
+}
+declare function Step({ status, className, children, markerClassName, contentClassName, align, icon, ...rest }: Props$4): react_jsx_runtime.JSX.Element;
+
+interface Props$3 extends ComponentPropsWithoutRef<"ul"> {
+    direction?: "horizontal" | "vertical";
+    lineStyle?: "solid" | "dashed" | "dotted";
+    markerType?: "circle" | "bullet";
+    /**
+     * if your Step is multiline keep it false
+     * better render and add line-space
+     *
+     * if your Steps are Sortable and eash Step si only one line
+     * and steps are vertical
+     * set it to true, line will not be animated when sorting
+     */
+    associateLineWithStep?: boolean;
+}
+declare function Steps({ direction, lineStyle, markerType, associateLineWithStep, className, ...rest }: Props$3): react_jsx_runtime.JSX.Element;
+
+declare function getIndexLetter(index: number): string;
+
+interface TooltipOptions {
+  initialOpen?: boolean;
+  placement?: Placement;
+  open?: boolean;
+  onOpen?: (open: boolean) => void;
+  openDelay?: number;
+  closeDelay?: number;
+  color?: ThemeColor;
+  contentClassName?: string;
+}
+
+interface Props$2 extends TooltipOptions {
+    children: ReactNode;
+}
+declare function Tooltip({ children, ...options }: Props$2): react_jsx_runtime.JSX.Element;
+
+declare const TooltipContent: (props: react.ClassAttributes<HTMLDivElement> & react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+interface Props$1 extends HTMLProps<HTMLElement> {
+    asChild?: boolean;
+}
+declare const TooltipTrigger: (props: Props$1 & react.RefAttributes<HTMLElement>) => react.ReactElement<any, string | react.JSXElementConstructor<any>> | null;
+
+declare function useTooltip({ initialOpen, placement, open: controlledOpen, onOpen: setControlledOpen, openDelay, closeDelay, color, }?: TooltipOptions): {
+    arrowRef: react.RefObject<HTMLDivElement>;
+    color: ThemeColor;
+    placement: _floating_ui_react.Placement;
+    strategy: _floating_ui_react.Strategy;
+    middlewareData: _floating_ui_react.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react.Placement;
+        strategy: _floating_ui_react.Strategy;
+        middlewareData: _floating_ui_react.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: ((open: boolean) => void) | undefined;
+};
+
+type ContextType = ReturnType<typeof useTooltip> | null;
+declare const TooltipContext: react.Context<ContextType>;
+declare function useTooltipContext(): {
+    arrowRef: react.RefObject<HTMLDivElement>;
+    color: ThemeColor;
+    placement: _floating_ui_react_dom.Placement;
+    strategy: _floating_ui_react_dom.Strategy;
+    middlewareData: _floating_ui_react_dom.MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: react.CSSProperties;
+    refs: {
+        reference: react.MutableRefObject<_floating_ui_react_dom.ReferenceType | null>;
+        floating: react.MutableRefObject<HTMLElement | null>;
+        setReference: (node: _floating_ui_react_dom.ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+    elements: {
+        reference: _floating_ui_react_dom.ReferenceType | null;
+        floating: HTMLElement | null;
+    } & _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: _floating_ui_react_dom.Placement;
+        strategy: _floating_ui_react_dom.Strategy;
+        middlewareData: _floating_ui_react_dom.MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: react.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event | undefined, reason?: _floating_ui_react.OpenChangeReason | undefined) => void;
+        events: _floating_ui_react.FloatingEvents;
+        dataRef: react.MutableRefObject<_floating_ui_react.ContextData>;
+        nodeId: string | undefined;
+        floatingId: string;
+        refs: _floating_ui_react.ExtendedRefs<_floating_ui_react.ReferenceType>;
+        elements: _floating_ui_react.ExtendedElements<_floating_ui_react.ReferenceType>;
+    };
+    getReferenceProps: (userProps?: react.HTMLProps<Element> | undefined) => Record<string, unknown>;
+    getFloatingProps: (userProps?: react.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getItemProps: (userProps?: (Omit<react.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean | undefined;
+        selected?: boolean | undefined;
+    }) | undefined) => Record<string, unknown>;
+    open: boolean;
+    setOpen: ((open: boolean) => void) | undefined;
+};
+
+interface Props extends TooltipOptions {
+    children: ReactNode;
+    content: ReactNode;
+}
+declare function SimpleTooltip({ content, children, contentClassName, ...options }: Props): react_jsx_runtime.JSX.Element;
+
+interface SortableItem<I> {
+  /** The unique id associated with your item. It's recommended this is the same as the key prop for your list item. */
+  id: string | number;
+  /** When true, the item is selected using MultiDrag */
+  selected?: boolean;
+  /** When true, the item is deemed "chosen", which basically just a mousedown event. */
+  chosen?: boolean;
+  /** When true, it will not be possible to pick this item up in the list. */
+  filtered?: boolean;
+
+  data: I;
+}
+
+declare function Sortable<T extends ItemInterface>({ children, list, setList, ...rest }: ReactSortableProps<T>): react_jsx_runtime.JSX.Element;
+
+declare function arrayEquals(a: any, b: any): boolean;
+
+type CustomFetchOptions = Omit<RequestInit, "body"> & {
+    body?: BodyInit | {
+        [key: string]: unknown;
+    };
+    urlParams?: {
+        [key: string]: string | number;
+    };
+    query?: {
+        [key: string]: unknown;
+    };
+};
+declare function fetchAPI(urlObjOrString: string | URL, enhancedOptions?: CustomFetchOptions, baseUrl?: string, baseOptions?: RequestInit): Promise<any>;
+declare class FetchError extends Error {
+    status: number;
+    data?: unknown;
+    constructor(message: string, status: number, data?: unknown);
+}
+
+declare function isErrorLike(err: any): err is Error;
+declare function parseError(err: any): [string, MessageOptions] | null;
+
+declare const useNotifications: () => {
+    addNotification: (content?: string, { expiration, color, canClose, withLoader, }?: Partial<Omit<Message, "id" | "message">>) => string;
+    removeNotification: (id: string) => void;
+    notifyError: (err: unknown) => void;
+};
+
+/**
+ * This hook accepts a ref to any element and adds a click event handler that creates ripples when click
+ */
+declare const useRipple: <T extends HTMLElement>(ref: react__default.RefObject<T>) => react_jsx_runtime.JSX.Element[];
+
+declare const useIsMounted: () => () => boolean;
+
+declare const useFetch: () => (urlObjOrString: string | URL, enhancedOptions?: CustomFetchOptions) => Promise<any>;
+
+declare const useCombinedRefs: <T extends unknown>(...refs: (Ref<T> | undefined)[]) => Ref<T>;
+
+declare function useIsClosing(initialValue?: boolean, delay?: number): {
+    isOpen: boolean;
+    isClosing: boolean;
+    setIsOpen: (newState: boolean) => void;
+};
+
+declare function usePrevious<T>(value: T): T | undefined;
+
+declare function useEventCallback<Args extends unknown[], R>(callback: ((...args: Args) => R) | null): (...args: Args) => R | undefined;
+
+declare function useDebounce<T>(value: T, delay?: number): [T, Dispatch<SetStateAction<T>>];
+declare function useRefDebounce<T>(value: T, delay?: number): MutableRefObject<T>;
+declare function useStateDebounce<T>(initialValue: T, delay?: number): [T, T, (initialValue: SetStateAction<T>, immediate?: boolean) => void];
+
+type CopiedValue = string | null;
+type CopyFn = (text: string) => Promise<boolean>;
+declare function useCopyToClipboard(): [CopiedValue, CopyFn];
+
+declare function useEventListener<K extends keyof MediaQueryListEventMap>(eventName: K, handler: (event: MediaQueryListEventMap[K]) => void, element: RefObject<MediaQueryList>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof HTMLElementEventMap & keyof SVGElementEventMap, T extends Element = K extends keyof HTMLElementEventMap ? HTMLDivElement : SVGElement>(eventName: K, handler: ((event: HTMLElementEventMap[K]) => void) | ((event: SVGElementEventMap[K]) => void), element: RefObject<T>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document>, options?: boolean | AddEventListenerOptions): void;
+
+type EventType = "mousedown" | "mouseup" | "touchstart" | "touchend" | "focusin" | "focusout";
+declare function useOnClickOutside<T extends HTMLElement = HTMLElement>(ref: RefObject<T> | RefObject<T>[], handler: (event: MouseEvent | TouchEvent | FocusEvent) => void, eventType?: EventType, eventListenerOptions?: AddEventListenerOptions): void;
+
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+
+declare const _default: {
+    handler: tailwindcss_types_config.PluginCreator;
+    config?: Partial<tailwindcss_types_config.Config> | undefined;
+};
+
+export { _default$1 as Autocomplete, _default$2 as AutocompleteOption, type AutocompleteProps, Badge, Button, ButtonGroup, type ButtonProps, Checkbox, Code, ContextMenu, ContextMenuItem, type ContextMenuItemMouseEvent, type CustomFetchOptions, Dialog, DropdownMenu, DropdownMenuContent, DropdownMenuContext, DropdownMenuItem, DropdownMenuNested, type DropdownMenuOptions, DropdownMenuTrigger, FetchError, Alert as Flash, Hightlight as Highlight, Href, Input, InputField, LazyAutocomplete, Loader, MenuItem, MenuItemWithChildren, Modal, ModalContent, ModalContext, ModalDescription, ModalFooter, ModalHeader, type ModalOptions, ModalTrigger, type NoDataOption, NotificationsContext, NotificationsProvider, type Option, type OptionLike, Popover, PopoverContent, PopoverContext, PopoverDescription, PopoverFooter, PopoverHeader, type PopoverOptions, PopoverTrigger, Portal, RadioGroup, ResizeArea, Scroll, Select, SelectContext, SelectOption, SelectSelection, type SelectSelectionProps, SimpleAutocomplete, SimpleTooltip, Snack, Sortable, type SortableItem, Step, Steps, Table$6 as Table, Table$5 as TableBody, Table$4 as TableCell, Table as TableFooter, Table$3 as TableHeader, Table$2 as TableHeaderCell, Table$1 as TableRow, Tabs, ThemeColor, Toggle, Tooltip, TooltipContent, TooltipContext, TooltipTrigger, arrayEquals, buttonVariants, cardConfig, dialogVariants, fetchAPI, getIndexLetter, getOptionLabel, getOptionValue, inputConfig, isErrorLike, parseError, _default as pentatrionTw, useAutocomplete, useCombinedRefs, useCopyToClipboard, useDebounce, useDropdownMenu, useDropdownMenuContext, useEventCallback, useEventListener, useFetch, useIsClosing, useIsMounted, useIsomorphicLayoutEffect, useModal, useModalContext, useNotifications, useOnClickOutside, usePopover, usePopoverContext, usePrevious, useRefDebounce, useRipple, useSelect, useStateDebounce, useTooltip, useTooltipContext };