@erxes/ui 0.0.0-stage → 3.2.20-1

package/dist/components/multiselect.d.ts

@@ -0,0 +1,72 @@
+import * as React from 'react';
+import { Command } from 'erxes-ui/components';
+export interface MultiSelectOption {
+    value: string;
+    label: string;
+    disable?: boolean;
+    /** fixed option that can‘t be removed. */
+    fixed?: boolean;
+    /** Group the options by providing key. */
+    [key: string]: string | boolean | undefined;
+}
+interface MultipleSelectorProps {
+    value?: MultiSelectOption[];
+    defaultOptions?: MultiSelectOption[];
+    /** manually controlled options */
+    options?: MultiSelectOption[];
+    placeholder?: string;
+    /** Loading component. */
+    loadingIndicator?: React.ReactNode;
+    /** Empty component. */
+    emptyIndicator?: React.ReactNode;
+    /** Debounce time for async search. Only work with `onSearch`. */
+    delay?: number;
+    /**
+     * Only work with `onSearch` prop. Trigger search when `onFocus`.
+     * For example, when user click on the input, it will trigger the search to get initial options.
+     **/
+    triggerSearchOnFocus?: boolean;
+    /** async search */
+    onSearch?: (value: string) => Promise<MultiSelectOption[]>;
+    /**
+     * sync search. This search will not showing loadingIndicator.
+     * The rest props are the same as async search.
+     * i.e.: creatable, groupBy, delay.
+     **/
+    onSearchSync?: (value: string) => MultiSelectOption[];
+    onChange?: (options: MultiSelectOption[]) => void;
+    /** Limit the maximum number of selected options. */
+    maxSelected?: number;
+    /** When the number of selected options exceeds the limit, the onMaxSelected will be called. */
+    onMaxSelected?: (maxLimit: number) => void;
+    /** Hide the placeholder when there are options selected. */
+    hidePlaceholderWhenSelected?: boolean;
+    disabled?: boolean;
+    /** Group the options base on provided key. */
+    groupBy?: string;
+    className?: string;
+    badgeClassName?: string;
+    /**
+     * First item selected is a default behavior by cmdk. That is why the default is true.
+     * This is a workaround solution by add a dummy item.
+     *
+     * @reference: https://github.com/pacocoursey/cmdk/issues/171
+     */
+    selectFirstItem?: boolean;
+    /** Allow user to create option when there is no option matched. */
+    creatable?: boolean;
+    /** Props of `Command` */
+    commandProps?: React.ComponentPropsWithoutRef<typeof Command>;
+    /** Props of `CommandInput` */
+    inputProps?: Omit<React.ComponentPropsWithoutRef<typeof Command.Input>, 'value' | 'placeholder' | 'disabled'>;
+    /** hide the clear all button. */
+    hideClearAllButton?: boolean;
+}
+export interface MultipleSelectorRef {
+    selectedValue: MultiSelectOption[];
+    input: HTMLInputElement;
+    focus: () => void;
+    reset: () => void;
+}
+export declare const MultipleSelector: React.ForwardRefExoticComponent<MultipleSelectorProps & React.RefAttributes<MultipleSelectorRef>>;
+export {};

package/dist/components/popover.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { Popover as PopoverPrimitive } from 'radix-ui';
+export type PopoverProps = React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Root>;
+export declare const popoverClassName = "z-50 w-72 rounded-md bg-background p-4 shadow-lg outline-hidden data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0";
+export declare const Popover: React.FC<PopoverPrimitive.PopoverProps> & {
+    Trigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        disableTransition?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Anchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+    Close: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+};

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

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { RadioGroup as RadioGroupPrimitive } from 'radix-ui';
+export type RadioGroupProps = React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root>;
+export declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>> & {
+    Item: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+};

package/dist/components/resizable.d.ts

@@ -0,0 +1,24 @@
+import * as ResizablePrimitive from 'react-resizable-panels';
+export declare const Resizable: {
+    PanelGroup: ({ className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => import("react/jsx-runtime").JSX.Element;
+    Panel: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLDivElement | HTMLElement | HTMLObjectElement | HTMLAnchorElement | HTMLButtonElement | HTMLFormElement | HTMLHeadingElement | HTMLImageElement | HTMLInputElement | HTMLLabelElement | HTMLLIElement | HTMLOListElement | HTMLParagraphElement | HTMLSelectElement | HTMLSpanElement | HTMLUListElement | HTMLAreaElement | HTMLAudioElement | HTMLBaseElement | HTMLQuoteElement | HTMLBodyElement | HTMLBRElement | HTMLCanvasElement | HTMLTableColElement | HTMLDataElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDialogElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLHeadElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLLegendElement | HTMLLinkElement | HTMLMapElement | HTMLMetaElement | HTMLMeterElement | HTMLOptGroupElement | HTMLOptionElement | HTMLOutputElement | HTMLPreElement | HTMLProgressElement | HTMLSlotElement | HTMLScriptElement | HTMLSourceElement | HTMLStyleElement | HTMLTableElement | HTMLTemplateElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTextAreaElement | HTMLTimeElement | HTMLTitleElement | HTMLTableRowElement | HTMLTrackElement | HTMLVideoElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
+        className?: string | undefined;
+        collapsedSize?: number | undefined;
+        collapsible?: boolean | undefined;
+        defaultSize?: number | undefined;
+        id?: string | undefined;
+        maxSize?: number | undefined;
+        minSize?: number | undefined;
+        onCollapse?: ResizablePrimitive.PanelOnCollapse | undefined;
+        onExpand?: ResizablePrimitive.PanelOnExpand | undefined;
+        onResize?: ResizablePrimitive.PanelOnResize | undefined;
+        order?: number | undefined;
+        style?: object | undefined;
+        tagName?: keyof HTMLElementTagNameMap | undefined;
+    } & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<ResizablePrimitive.ImperativePanelHandle>>;
+    Handle: ({ withHandle, className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+        withHandle?: boolean;
+    }) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/scroll-area.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { ScrollArea as ScrollAreaPrimitive } from 'radix-ui';
+export declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    scrollBarClassName?: string;
+    viewportClassName?: string;
+} & React.RefAttributes<HTMLDivElement>> & {
+    Root: React.ForwardRefExoticComponent<Omit<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        scrollBarClassName?: string;
+        viewportClassName?: string;
+    } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Viewport: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Bar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};

package/dist/components/search-order-select.d.ts

@@ -0,0 +1,8 @@
+export type TSearchSortOrder = 'newest' | 'oldest';
+export declare const SearchOrderSelect: ({ value, newestLabel, oldestLabel, triggerClassName, onValueChange, }: {
+    value: TSearchSortOrder;
+    newestLabel: string;
+    oldestLabel: string;
+    triggerClassName?: string;
+    onValueChange: (value: TSearchSortOrder) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/select.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { Select as SelectPrimitive } from 'radix-ui';
+export declare const Select: React.FC<SelectPrimitive.SelectProps> & {
+    Group: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+    Value: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+    Primitive: typeof SelectPrimitive;
+    Trigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    ScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    ScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};

package/dist/components/separator.d.ts

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

package/dist/components/sheet.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { Dialog as SheetPrimitive } from 'radix-ui';
+import { type VariantProps } from 'class-variance-authority';
+declare const sheetVariants: (props?: {
+    side?: "top" | "right" | "bottom" | "left";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const SheetPortal: {
+    ({ ...props }: React.ComponentPropsWithoutRef<typeof SheetPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+export declare const SheetClose: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const Sheet: {
+    ({ ...props }: React.ComponentPropsWithoutRef<typeof SheetPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} & {
+    Trigger: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Overlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    View: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+    Content: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Title: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+    Close: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/components/sidebar/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const SIDEBAR_COOKIE_NAME = "sidebar:state";
+export declare const SIDEBAR_COLLAPSE_COOKIE_NAME = "sidebar:collapse";
+export declare const SIDEBAR_COOKIE_MAX_AGE: number;
+export declare const SIDEBAR_WIDTH = "16rem";
+export declare const SIDEBAR_WIDTH_COMPACT = "12rem";
+export declare const SIDEBAR_WIDTH_MOBILE = "18rem";
+export declare const SIDEBAR_WIDTH_ICON = "3rem";
+export declare const SIDEBAR_KEYBOARD_SHORTCUT = "b";
+export type CollapseState = 'expanded' | 'compact' | 'collapsed';
+export declare const COLLAPSE_ORDER: CollapseState[];
+export declare const nextCollapseState: (prev: CollapseState) => CollapseState;

package/dist/components/sidebar/context.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { type CollapseState } from './constants';
+type ISidebarContext = {
+    state: 'expanded' | 'collapsed';
+    collapseState: CollapseState;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+export declare function useOptionalSidebar(): ISidebarContext;
+export declare function useSidebar(): ISidebarContext;
+export declare const SidebarProvider: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    collapseState?: CollapseState;
+    defaultCollapseState?: CollapseState;
+    onCollapseStateChange?: (state: CollapseState) => void;
+    sidebarKeyboardShortcut?: string | false;
+    sidebarWidth?: string;
+    sidebarWidthIcon?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/sidebar/group.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export declare const SidebarGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarGroupLabel: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarGroupAction: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SidebarGroupContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/hooks.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const useComposedRef: <T extends HTMLElement>(forwardedRef: React.ForwardedRef<T>) => readonly [React.MutableRefObject<T>, (node: T | null) => void];

package/dist/components/sidebar/layout.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export declare const SidebarInput: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement> & {
+    variant?: "default" | "secondary";
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export declare const SidebarHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarSeparator: React.ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-separator").SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarContent: React.ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-scroll-area").ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    scrollBarClassName?: string;
+    viewportClassName?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/menu-sub.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare const SidebarMenuSub: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+export declare const SidebarMenuSubItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+export declare const SidebarMenuSubButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}, "ref"> & React.RefAttributes<HTMLAnchorElement>>;

package/dist/components/sidebar/menu.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { Tooltip } from 'erxes-ui/components/tooltip';
+export declare const SidebarMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+export declare const SidebarMenuItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+export declare const SidebarMenuButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof Tooltip.Content>;
+    tooltipVisibility?: "collapsed" | "always";
+} & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SidebarMenuAction: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SidebarMenuBadge: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarMenuSkeleton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    showIcon?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/panel.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export declare const SidebarPanelTrigger: React.ForwardRefExoticComponent<Omit<import("erxes-ui/components/button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SidebarPanel: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    actions?: React.ReactNode;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/root.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export declare const SidebarRoot: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+    mobileClassName?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare const SidebarRail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SidebarInset: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/trigger.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const SidebarTrigger: React.ForwardRefExoticComponent<Omit<import("erxes-ui/components/button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/sidebar-tree-indicator.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export type TFindActiveTreeItem = (container: HTMLElement) => HTMLElement | null;
+export declare const findActiveSubItem: TFindActiveTreeItem;
+export declare const SidebarTreeIndicator: ({ as: Element, containerRef, findActive, }: Readonly<{
+    as?: "li" | "span";
+    containerRef: React.RefObject<HTMLElement | null>;
+    findActive?: TFindActiveTreeItem;
+}>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/sidebar.d.ts

@@ -0,0 +1,78 @@
+import { useOptionalSidebar, useSidebar } from './sidebar/context';
+export declare const Sidebar: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+    mobileClassName?: string;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>> & {
+    Content: import("react").ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-scroll-area").ScrollAreaProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+        scrollBarClassName?: string;
+        viewportClassName?: string;
+    } & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Footer: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Group: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    GroupAction: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+        asChild?: boolean;
+    }, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    GroupContent: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    GroupLabel: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Header: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Input: import("react").ForwardRefExoticComponent<Omit<import("react").InputHTMLAttributes<HTMLInputElement> & {
+        variant?: "default" | "secondary";
+    } & import("react").RefAttributes<HTMLInputElement>, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+    Inset: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Panel: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+        label?: React.ReactNode;
+        actions?: React.ReactNode;
+    }, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    PanelTrigger: import("react").ForwardRefExoticComponent<Omit<import("./button").ButtonProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    Menu: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & import("react").RefAttributes<HTMLUListElement>>;
+    MenuAction: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+        asChild?: boolean;
+        showOnHover?: boolean;
+    }, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    MenuBadge: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    MenuButton: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+        asChild?: boolean;
+        isActive?: boolean;
+        tooltip?: string | React.ComponentProps<import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-tooltip").TooltipContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;
+        tooltipVisibility?: "collapsed" | "always";
+    } & import("class-variance-authority").VariantProps<(props?: {
+        variant?: "default" | "outline";
+        size?: "default" | "sm" | "lg";
+    } & import("class-variance-authority/types").ClassProp) => string>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    MenuItem: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+    MenuSkeleton: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+        showIcon?: boolean;
+    }, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Sub: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & import("react").RefAttributes<HTMLUListElement>>;
+    TreeIndicator: ({ as: Element, containerRef, findActive, }: Readonly<{
+        as?: "li" | "span";
+        containerRef: React.RefObject<HTMLElement | null>;
+        findActive?: import("./sidebar-tree-indicator").TFindActiveTreeItem;
+    }>) => import("react/jsx-runtime").JSX.Element;
+    SubButton: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLAnchorElement> & import("react").AnchorHTMLAttributes<HTMLAnchorElement> & {
+        asChild?: boolean;
+        size?: "sm" | "md";
+        isActive?: boolean;
+    }, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
+    SubItem: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+    Provider: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+        defaultOpen?: boolean;
+        open?: boolean;
+        onOpenChange?: (open: boolean) => void;
+        collapseState?: import("./sidebar/constants").CollapseState;
+        defaultCollapseState?: import("./sidebar/constants").CollapseState;
+        onCollapseStateChange?: (state: import("./sidebar/constants").CollapseState) => void;
+        sidebarKeyboardShortcut?: string | false;
+        sidebarWidth?: string;
+        sidebarWidthIcon?: string;
+    }, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Rail: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    Separator: import("react").ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-separator").SeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("./button").ButtonProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    useOptionalSidebar: typeof useOptionalSidebar;
+    useSidebar: typeof useSidebar;
+};

package/dist/components/skeleton.d.ts

@@ -0,0 +1,4 @@
+export declare const Skeleton: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+export declare const SkeletonArray: ({ className, count, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    count: number;
+}) => import("react/jsx-runtime").JSX.Element[];

package/dist/components/slider.d.ts

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

package/dist/components/spinner.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+declare const spinnerVariants: (props?: {
+    show?: boolean;
+} & import("class-variance-authority/types").ClassProp) => string;
+declare const loaderVariants: (props?: {
+    size?: "default" | "sm" | "lg" | "md";
+} & import("class-variance-authority/types").ClassProp) => string;
+interface SpinnerContentProps extends VariantProps<typeof spinnerVariants>, VariantProps<typeof loaderVariants> {
+    className?: string;
+    containerClassName?: string;
+    withMascot?: boolean;
+}
+export declare function Spinner({ size, show, className, containerClassName, withMascot, }: SpinnerContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/stepper.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: 'horizontal' | 'vertical';
+}
+interface StepperItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    step: number;
+    completed?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+}
+interface StepperTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+interface StepperIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    asChild?: boolean;
+}
+export declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<HTMLDivElement>> & {
+    Item: React.ForwardRefExoticComponent<StepperItemProps & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<StepperTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Indicator: React.ForwardRefExoticComponent<StepperIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+    Separator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+};
+export {};

package/dist/components/string-array.d.ts

@@ -0,0 +1,16 @@
+export declare function StringArrayInput({ value, onValueChange, id, placeholder, styleClasses, onBlur, splitOnPaste, }: {
+    value: string[];
+    onValueChange: (value: string[]) => void;
+    id?: string;
+    placeholder?: string;
+    styleClasses?: {
+        inlineTagsContainer?: string;
+        input?: string;
+        tag?: {
+            body?: string;
+            closeButton?: string;
+        };
+    };
+    onBlur?: () => void;
+    splitOnPaste?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/switch.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { Switch as SwitchPrimitives } from 'radix-ui';
+import { type VariantProps } from 'class-variance-authority';
+export declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+    size?: "default" | "sm";
+} & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>> & {
+    Header: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+    Body: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+    Footer: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+    Head: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+    Row: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+    Cell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+    Caption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+};

package/dist/components/tabs.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import { type VariantProps } from 'class-variance-authority';
+export declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>> & {
+    List: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & VariantProps<(props?: {
+        variant?: "underline" | "segment";
+    } & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: {
+        variant?: "underline" | "segment";
+    } & import("class-variance-authority/types").ClassProp) => string> & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Primitive: typeof TabsPrimitive;
+};

package/dist/components/text-overflow.d.ts

@@ -0,0 +1,15 @@
+import { type InputHTMLAttributes } from 'react';
+interface TextOverflowTooltipProps {
+    value?: string;
+    className?: string;
+    delayDuration?: number;
+}
+interface TextOverflowTooltipInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange'> {
+    value?: string;
+    onChange?: (value: string) => void;
+    delayDuration?: number;
+}
+export declare const TextOverflowTooltip: import("react").ForwardRefExoticComponent<TextOverflowTooltipProps & import("react").RefAttributes<HTMLSpanElement>> & {
+    Input: import("react").ForwardRefExoticComponent<TextOverflowTooltipInputProps & import("react").RefAttributes<HTMLInputElement>>;
+};
+export {};

package/dist/components/textarea.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;

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

@@ -0,0 +1,11 @@
+import { DateFieldProps, DateInputProps as DateInputPropsRac, DateSegmentProps, DateValue as DateValueRac, TimeFieldProps, TimeValue as TimeValueRac } from 'react-aria-components';
+declare function DateField<T extends DateValueRac>({ className, children, ...props }: DateFieldProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function TimeField<T extends TimeValueRac>({ className, children, ...props }: TimeFieldProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function DateSegment({ className, ...props }: DateSegmentProps): import("react/jsx-runtime").JSX.Element;
+interface DateInputProps extends DateInputPropsRac {
+    className?: string;
+    unstyled?: boolean;
+}
+declare function DateInput({ className, unstyled, ...props }: Omit<DateInputProps, 'children'>): import("react/jsx-runtime").JSX.Element;
+export { DateField, DateInput, DateSegment, TimeField };
+export type { DateInputProps };

package/dist/components/toaster.d.ts

@@ -0,0 +1 @@
+export declare function Toaster(): import("react/jsx-runtime").JSX.Element;

package/dist/components/toasts.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { Toast as ToastPrimitives } from 'radix-ui';
+declare const ToastRoot: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & {
+    variant?: "success" | "warning" | "destructive" | "default";
+} & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export type ToastProps = React.ComponentPropsWithoutRef<typeof ToastRoot>;
+export type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & {
+    variant?: "success" | "warning" | "destructive" | "default";
+} & React.RefAttributes<HTMLLIElement>> & {
+    Provider: React.FC<ToastPrimitives.ToastProviderProps>;
+    Viewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+    Action: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Close: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Title: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Description: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+export {};