ezux 1.0.0

package/dist/components/EzTreeView/hooks/useTreeState.d.ts

@@ -0,0 +1,21 @@
+import { EzTreeViewProps, TreeNode } from '../EzTreeView.types';
+/**
+ * Hook for managing the core data and processing logic for the tree.
+ *
+ * Handles field mapping, sorting, and synchronizing external data changes.
+ *
+ * @param props Props for the EzTreeView component.
+ * @group Hooks
+ */
+export declare const useTreeState: (props: EzTreeViewProps) => {
+    /** The processed tree data structure. @group State */
+    treeData: TreeNode[];
+    /** Update the internal tree data. @group Methods */
+    setInternalTreeData: (updater: any) => void;
+    /** Set of node IDs currently in a loading state. @group State */
+    loadingNodes: Set<string>;
+    /** Update the loading state of nodes. @group Methods */
+    setLoadingNodes: (updater: any) => void;
+    /** Update a specific node by ID. @group Methods */
+    updateNode: (id: string, updates: Partial<TreeNode>) => void;
+};

package/dist/components/EzTreeView/hooks/useTreeVirtualization.d.ts

@@ -0,0 +1,18 @@
+import { TreeNode } from '../EzTreeView.types';
+/**
+ * Hook for flattening tree data for virtualization and applying search filters.
+ *
+ * Computes a visible flat list of nodes based on expansion state and search term matches.
+ *
+ * @param treeData The full tree data.
+ * @param expandedNodes Set of IDs for currently expanded nodes.
+ * @param searchTerm Optional search query for filtering nodes.
+ * @group Hooks
+ */
+export declare const useTreeVirtualization: (treeData: TreeNode[], expandedNodes: Set<string>, searchTerm?: string) => {
+    /** The flattened list of visible nodes and their levels. @group State */
+    flattenedNodes: {
+        node: TreeNode;
+        level: number;
+    }[];
+};

package/dist/components/EzTreeView/index.d.ts

@@ -0,0 +1,40 @@
+import { default as React } from 'react';
+import { EzTreeViewProps } from './EzTreeView.types';
+/**
+ * EzTreeView is a high-performance hierarchical data explorer.
+ * It uses a virtualized engine to efficiently render trees with thousands of
+ * nodes while providing rich interactive features like drag-and-drop and
+ * multi-level selection.
+ *
+
+ * ### Key Features
+ * - **Superior Virtualization**: Flat-list virtualization for smooth scrolling even with deep, expanded trees.
+ * - **Flexible Selection**: Supports `single`, `multiple`, and `checkbox` selection modes with indeterminate state support.
+ * - **Drag & Drop**: Native `@dnd-kit` integration for reordering nodes and changing parent-child relationships.
+ * - **Inline Editing**: Double-click to rename nodes with built-in validation.
+ * - **Search & Filter**: Real-time filtering with automatic expansion of matching parent nodes.
+ * - **Custom Rendering**: Fully customizable node templates and icons via the `components` prop.
+ *
+ * ### Minimal Example
+ * ```tsx
+ * <EzTreeView
+ *   data={myTreeData}
+ *   showCheckboxes
+ *   onNodeClicked={(node) => console.log('Clicked:', node.text)}
+ * />
+ * ```
+ *
+ * ### Advanced Config: Virtualization & DND
+ * ```tsx
+ * <EzTreeView
+ *   data={largeTreeData}
+ *   allowDragAndDrop
+ *   allowEditing
+ *   onNodeDrop={(dragged, target, position) => handleMove(dragged, target, position)}
+ *   className="h-[400px] border rounded-md"
+ * />
+ * ```
+ *
+ * @group Core Components
+ */
+export declare const EzTreeView: React.FC<EzTreeViewProps>;

package/dist/components/EzTreeView/services/TreeService.d.ts

@@ -0,0 +1,11 @@
+import { ITreeService, TreeNode } from '../EzTreeView.types';
+export declare class TreeService implements ITreeService {
+    name: string;
+    constructor();
+    private simulateLatency;
+    loadNodes(parentId?: string): Promise<TreeNode[]>;
+    moveNode(id: string, targetParentId: string, index?: number): Promise<void>;
+    renameNode(id: string, newName: string): Promise<void>;
+    deleteNode(id: string): Promise<void>;
+    addNode(parentId: string, node: Partial<TreeNode>): Promise<TreeNode>;
+}

package/dist/components/EzTreeView/useEzTreeView.d.ts

@@ -0,0 +1,62 @@
+import { EzTreeViewProps, TreeNode } from './EzTreeView.types';
+/**
+ * The main orchestrator hook for EzTreeView.
+ *
+ * Coordinates specialized hooks for tree state, expansion, multi-selection,
+ * virtualization, and imperative API access.
+ *
+ * @param props Props for the EzTreeView component.
+ * @group Hooks
+ */
+export declare const useEzTreeView: (props: EzTreeViewProps) => {
+    /** The current state of the tree nodes. @group State */
+    treeData: TreeNode[];
+    /** Set of IDs for currently expanded nodes. @group State */
+    expandedNodes: Set<string>;
+    /** Set of IDs for currently selected nodes. @group State */
+    selectedNodes: Set<string>;
+    /** Set of IDs for currently checked nodes. @group State */
+    checkedNodes: Set<string>;
+    /** Set of IDs for nodes in an indeterminate check state. @group State */
+    indeterminateNodes: Set<string>;
+    /** Map of nodes currently being loaded (async). @group State */
+    loadingNodes: Set<string>;
+    /** Flattened list of visible nodes for rendering. @group State */
+    flattenedNodes: {
+        node: TreeNode;
+        level: number;
+    }[];
+    /** Toggle expansion state of a node. @group Methods */
+    toggleExpand: (nodeId: string) => Promise<void>;
+    /** Toggle selection state of a node. @group Methods */
+    toggleSelect: (nodeId: string) => void;
+    /** Toggle check state of a node. @group Methods */
+    toggleCheck: (nodeId: string) => void;
+    /** Rename a node. @group Methods */
+    handleNodeRename: (nodeId: string, newLabel: string) => void;
+    /** Text direction (ltr/rtl). @group Properties */
+    dir: "ltr" | "rtl";
+    /** Whether text wrapping is allowed. @group Properties */
+    allowTextWrap: boolean | undefined;
+    /** Animation configuration. @group Properties */
+    animation: boolean | {
+        expand?: boolean;
+        collapse?: boolean;
+    } | undefined;
+    /** Whether to check on click. @group Properties */
+    checkOnClick: boolean | undefined;
+    /** Whether full row selection is enabled. @group Properties */
+    fullRowSelect: boolean | undefined;
+    /** Whether full row navigation is enabled. @group Properties */
+    fullRowNavigable: boolean | undefined;
+    /** Key press handler. @group Events */
+    onKeyPress: ((event: React.KeyboardEvent) => void) | undefined;
+    /** Node click handler. @group Events */
+    onNodeClicked: ((nodeId: string) => void) | undefined;
+    /** Draw node callback. @group Events */
+    onDrawNode: ((node: TreeNode) => void) | undefined;
+    /** ID of the node currently being edited. @group State */
+    editingNodeId: string | null;
+    /** Handler to set the editing node. @group Methods */
+    setEditingNodeId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+};

package/dist/components/EzTreeView/utils/treeUtils.d.ts

@@ -0,0 +1,17 @@
+import { TreeNode, EzTreeViewProps } from '../EzTreeView.types';
+/**
+ * Utility to map custom fields to TreeNode structure
+ */
+export declare const mapFieldsToTreeNode: (data: any, fields?: EzTreeViewProps["fields"]) => TreeNode;
+/**
+ * Utility to sort tree data
+ */
+export declare const sortTreeData: (data: TreeNode[], sortOrder?: "None" | "Ascending" | "Descending") => TreeNode[];
+/**
+ * Utility to find a node by ID
+ */
+export declare const findNodeById: (nodes: import('../../../shared/types').TreeNode[], id: string) => import('../../../shared/types').TreeNode | undefined;
+/**
+ * Utility to update a node in the tree
+ */
+export declare const updateNodeInNodes: (nodes: import('../../../shared/types').TreeNode[], id: string, updates: Partial<import('../../../shared/types').TreeNode>) => import('../../../shared/types').TreeNode[];

package/dist/components/shared/components/EzErrorBoundary.d.ts

@@ -0,0 +1,18 @@
+import { Component, ErrorInfo, ReactNode } from 'react';
+interface EzErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface EzErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+}
+export declare class EzErrorBoundary extends Component<EzErrorBoundaryProps, EzErrorBoundaryState> {
+    constructor(props: EzErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): EzErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleReset: () => void;
+    render(): ReactNode;
+}
+export default EzErrorBoundary;

package/dist/components/shared/components/EzLayoutErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzLayoutErrorFallback: React.FC;

package/dist/components/shared/components/EzLoadingSpinner.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export type LoadingSpinnerVariant = 'primary' | 'blue';
+export interface EzLoadingSpinnerProps {
+    variant?: LoadingSpinnerVariant;
+    text?: string;
+    className?: string;
+}
+export declare const EzLoadingSpinner: React.FC<EzLoadingSpinnerProps>;

package/dist/components/shared/components/EzSchedulerErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzSchedulerErrorFallback: React.FC;

package/dist/components/shared/components/EzTableErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzTableErrorFallback: React.FC;

package/dist/components/shared/components/EzTreeViewErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const EzTreeViewErrorFallback: React.FC;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const Avatar: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<React.ImgHTMLAttributes<HTMLImageElement> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

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

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

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

@@ -0,0 +1,19 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    isLoading?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

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

@@ -0,0 +1,15 @@
+export type CalendarProps = {
+    selected?: Date;
+    onSelect?: (date: Date | undefined) => void;
+    className?: string;
+    locale?: string;
+    minDate?: Date;
+    modifiers?: {
+        [date: string]: {
+            className?: string;
+            tooltip?: string;
+            disabled?: boolean;
+        };
+    };
+};
+export declare function Calendar({ selected, onSelect, className, locale, minDate, modifiers }: CalendarProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'checked'> {
+    checked?: boolean | 'indeterminate';
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+export { Checkbox };

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

@@ -0,0 +1,78 @@
+import * as React from "react";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/context-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+declare const ContextMenu: React.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

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

@@ -0,0 +1,13 @@
+interface DateTimePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    disabled?: boolean;
+    required?: boolean;
+    id?: string;
+    locale?: string;
+    className?: string;
+    mode?: 'date' | 'datetime';
+    minDate?: Date;
+}
+export declare function DateTimePicker({ date, setDate, disabled, id, locale, className, mode, minDate }: DateTimePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

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

@@ -0,0 +1,26 @@
+export * from './avatar';
+export * from './breadcrumb';
+export * from './button';
+export * from './calendar';
+export * from './card';
+export * from './checkbox';
+export * from './command';
+export * from './context-menu';
+export * from './date-time-picker';
+export * from './dropdown-menu';
+export * from './input';
+export * from './label';
+export * from './password-input';
+export * from './popover';
+export * from './select';
+export * from './skeleton';
+export * from './switch';
+export * from './table';
+export * from './tabs';
+export * from './textarea';
+export * from './tooltip';
+export * from './scroll-area';
+export * from './radio-group';
+export * from './badge';
+export * from './progress';
+export * from './modal';

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

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

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import('class-variance-authority/types').ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

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

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const Modal: React.FC<ModalProps>;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface PasswordInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const PasswordInput: React.ForwardRefExoticComponent<PasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+export { PasswordInput };

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

@@ -0,0 +1,4 @@
+import * as React from "react";
+export declare const Popover: React.FC<import('@radix-ui/react-dropdown-menu').DropdownMenuProps>;
+export declare const PopoverTrigger: React.ForwardRefExoticComponent<import('@radix-ui/react-dropdown-menu').DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const PopoverContent: React.ForwardRefExoticComponent<Omit<Omit<import('@radix-ui/react-dropdown-menu').DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+export { Progress };

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as RadioGroupPrimitives from "@radix-ui/react-radio-group";
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitives.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitives.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { RadioGroup, RadioGroupItem };

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+declare function ScrollArea({ className, children, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Scrollbar>): import("react/jsx-runtime").JSX.Element;
+export { ScrollArea, ScrollBar };

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

@@ -0,0 +1,24 @@
+import * as React from "react";
+interface SelectProps {
+    value?: any;
+    onValueChange?: (value: any) => void;
+    children: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare const Select: React.FC<SelectProps>;
+export declare const SelectTrigger: React.FC<{
+    className?: string;
+    children: React.ReactNode;
+}>;
+export declare const SelectValue: React.FC<{
+    placeholder?: string;
+}>;
+export declare const SelectContent: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const SelectItem: React.FC<{
+    value: any;
+    children: React.ReactNode;
+}>;
+export {};

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

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

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

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

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

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

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

@@ -0,0 +1,14 @@
+import * as React from 'react';
+declare const Tabs: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };