@zimyo/ui 1.10.10 → 1.10.11

package/dist/index.d.ts

@@ -0,0 +1,839 @@
+import * as React$1 from 'react';
+import React__default, { ElementType, ReactNode, CSSProperties } from 'react';
+import { ButtonProps as ButtonProps$1, PopoverProps as PopoverProps$1, CardProps, AccordionProps as AccordionProps$1, AccordionSummaryProps, AccordionDetailsProps, SwitchProps as SwitchProps$1, TypographyProps, SxProps as SxProps$1 } from '@mui/material';
+import { SxProps } from '@mui/system';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Props, GroupBase } from 'react-select';
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import { VariantProps } from 'class-variance-authority';
+import { UseFormReturn, Controller } from 'react-hook-form';
+import { Dayjs } from 'dayjs';
+import { ColumnDef, SortingState } from '@tanstack/react-table';
+import { LucideIcon } from 'lucide-react';
+import { Theme } from '@mui/material/styles';
+import { ClassValue } from 'clsx';
+
+interface ButtonProps extends Omit<ButtonProps$1, 'sx'> {
+    loading?: boolean;
+    loadingText?: string;
+    sx?: SxProps;
+    loaderSize?: number;
+    loaderPosition?: 'start' | 'end' | 'center';
+}
+declare const Button: React__default.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface PopoverProps extends Partial<PopoverProps$1> {
+    open: boolean;
+    onClose: () => void;
+    anchorEl: HTMLElement | null;
+    children: React__default.ReactNode;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    padding?: number;
+    border?: boolean;
+}
+declare const Popover: ({ open, onClose, anchorEl, children, width, maxWidth, minWidth, padding, border, anchorOrigin, transformOrigin, ...rest }: PopoverProps) => react_jsx_runtime.JSX.Element;
+
+interface CardRootProps extends CardProps {
+    sx?: SxProps;
+    variant?: 'elevated' | 'outlined' | 'bordered';
+    children: React__default.ReactNode;
+}
+declare const CardRoot: React__default.FC<CardRootProps>;
+
+declare const CardHeader: ({ title, subtitle, action, sx, }: {
+    title?: string | React__default.ReactNode;
+    subtitle?: string | React__default.ReactNode;
+    action?: React__default.ReactNode;
+    sx?: any;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const CardContent: ({ children, sx }: {
+    children: React__default.ReactNode;
+    sx?: any;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const CardActions: ({ children, sx }: {
+    children: React__default.ReactNode;
+    sx?: any;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const CardImage: ({ src, height, alt, sx }: {
+    src: string;
+    height?: number | string;
+    alt?: string;
+    sx?: any;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const CardSkeleton: ({ lines }: {
+    lines?: number;
+}) => react_jsx_runtime.JSX.Element;
+
+interface Option {
+    label?: string;
+    value?: string | number;
+    leftIcon?: string | React__default.ReactNode;
+    rightIcon?: string | React__default.ReactNode;
+    [key: string]: any;
+}
+type SelectSize = "xs" | "sm" | "md" | "lg";
+interface SelectProps extends Omit<Props<Option, boolean, GroupBase<Option>>, 'options'> {
+    label?: string;
+    error?: string;
+    isClearable?: boolean;
+    isSearchable?: boolean;
+    className?: string;
+    size?: SelectSize;
+    required?: boolean;
+    valueKey?: string;
+    labelKey?: string;
+    searchByID?: boolean;
+    value?: any;
+    floatingLabel?: boolean;
+    maxChipVisible?: number;
+    description?: string;
+    options?: Option[];
+    loadOptions?: (inputValue: string) => Promise<Option[]>;
+    cacheOptions?: boolean;
+    defaultOptions?: boolean | Option[];
+}
+declare function Select({ label, error, className, size, required, valueKey, labelKey, isMulti, value, options, loadOptions, cacheOptions, defaultOptions, onChange, searchByID, floatingLabel, maxChipVisible, description, isDisabled, ...props }: SelectProps): react_jsx_runtime.JSX.Element;
+
+interface AccordionProps extends Omit<AccordionProps$1, 'sx' | 'onChange' | 'expanded'> {
+    type?: 'single' | 'multiple';
+    collapsible?: boolean;
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    children: React__default.ReactNode;
+    sx?: SxProps;
+}
+interface AccordionItemProps extends Omit<AccordionProps$1, 'sx'> {
+    value: string;
+    children: React__default.ReactNode;
+    sx?: SxProps;
+}
+interface AccordionTriggerProps extends Omit<AccordionSummaryProps, 'sx'> {
+    children: React__default.ReactNode;
+    sx?: SxProps;
+    expandIcon?: React__default.ReactNode;
+}
+interface AccordionContentProps extends Omit<AccordionDetailsProps, 'sx'> {
+    children: React__default.ReactNode;
+    sx?: SxProps;
+}
+declare const Accordion: React__default.ForwardRefExoticComponent<Omit<AccordionProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React__default.ForwardRefExoticComponent<Omit<AccordionItemProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React__default.ForwardRefExoticComponent<Omit<AccordionTriggerProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const AccordionContent: React__default.ForwardRefExoticComponent<Omit<AccordionContentProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+interface SwitchProps extends Omit<SwitchProps$1, 'onChange'> {
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+    required?: boolean | number;
+    labelPlacement?: 'end' | 'start' | 'bottom' | 'top';
+    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+}
+declare const Switch: React__default.ForwardRefExoticComponent<Omit<SwitchProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface RadioOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    description?: string;
+}
+interface RadioGroupProps {
+    label?: string;
+    options: RadioOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    name?: string;
+    disabled?: boolean;
+    required?: boolean;
+    error?: boolean;
+    helperText?: string;
+    row?: boolean;
+    size?: 'small' | 'medium';
+    color?: 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
+    sx?: SxProps;
+    radioSx?: SxProps;
+    labelSx?: SxProps;
+}
+declare const RadioGroup: React__default.ForwardRefExoticComponent<RadioGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface HeadingProps extends TypographyProps {
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+declare const Heading: ({ level, ...props }: HeadingProps) => react_jsx_runtime.JSX.Element;
+
+interface TextProps extends TypographyProps {
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Text: ({ size, ...props }: TextProps) => react_jsx_runtime.JSX.Element;
+
+declare const Lead: (props: TypographyProps) => react_jsx_runtime.JSX.Element;
+
+declare const Muted: (props: TypographyProps) => react_jsx_runtime.JSX.Element;
+
+declare const Strong: (props: TypographyProps) => react_jsx_runtime.JSX.Element;
+
+declare const Caption: (props: TypographyProps) => react_jsx_runtime.JSX.Element;
+
+declare const Blockquote: (props: TypographyProps) => react_jsx_runtime.JSX.Element;
+
+interface CodeProps {
+    children: React.ReactNode;
+    sx?: SxProps$1;
+}
+declare const Code: ({ children, sx }: CodeProps) => react_jsx_runtime.JSX.Element;
+
+interface ModalProps {
+    open: boolean;
+    onClose: () => void;
+    title?: string | any;
+    description?: string;
+    children?: React$1.ReactNode;
+    actions?: React$1.ReactNode;
+    showCloseIcon?: boolean;
+    maxWidth?: false | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    fullWidth?: boolean;
+    fullScreen?: boolean;
+    className?: string;
+    allowActionBorder?: boolean;
+}
+declare const Modal: React$1.FC<ModalProps>;
+
+interface DrawerProps {
+    open: boolean;
+    onClose: () => void;
+    title?: string;
+    children: React$1.ReactNode;
+    footer?: React$1.ReactNode;
+    side?: "left" | "right" | "top" | "bottom";
+    className?: string;
+    showCloseIcon?: boolean;
+    withOverlay?: boolean;
+    stickyFooter?: boolean;
+    width?: number | string;
+    height?: number | string;
+}
+declare const Drawer: React$1.FC<DrawerProps>;
+
+type Position = "start" | "end";
+interface CustomColor {
+    bg?: string;
+    text?: string;
+    border?: string;
+}
+interface BadgeProps extends VariantProps<typeof badgeVariants> {
+    label: string;
+    icon?: React__default.ReactNode;
+    iconPosition?: Position;
+    dot?: boolean;
+    dotPosition?: Position;
+    color?: CustomColor;
+    className?: string;
+}
+declare const badgeVariants: (props?: ({
+    variant?: "text" | "outlined" | "contained" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    type?: "default" | "success" | "error" | "info" | "warning" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+declare const Badge: ({ label, icon, iconPosition, dot, dotPosition, variant, size, type, color, className, }: BadgeProps) => react_jsx_runtime.JSX.Element;
+
+type InputSize$3 = "xs" | "sm" | "md" | "lg";
+type InputVariant$1 = "outlined" | "contained";
+interface InputProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    floatingLabel?: boolean;
+    description?: string;
+    error?: string;
+    leftIcon?: React$1.ReactNode;
+    rightIcon?: React$1.ReactNode;
+    size?: InputSize$3;
+    variant?: InputVariant$1;
+    allowedPattern?: "number" | "alpha" | RegExp;
+    onLeftIconClick?: () => void;
+    onRightIconClick?: () => void;
+    debounceDelay?: number;
+    onDebouncedChange?: (value: string) => void;
+    wordLimit?: number;
+    focusOutline?: boolean;
+}
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement | HTMLTextAreaElement>>;
+
+type NoticeVariant = 'success' | 'error' | 'warning' | 'info';
+type NoticeSize = 'sm' | 'md' | 'lg';
+type NoticeStyleType = 'contained' | 'outlined';
+interface NoticeProps {
+    title?: string;
+    message: string;
+    variant?: NoticeVariant;
+    size?: NoticeSize;
+    styleType?: NoticeStyleType;
+    onClose?: () => void;
+    className?: string;
+    showCloseIcon?: boolean;
+}
+declare const Notice: React$1.FC<NoticeProps>;
+
+type DayOfWeek = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+type DateRange = {
+    from: Date;
+    to: Date;
+};
+type DisabledDateObject = {
+    dayOfWeek: DayOfWeek[];
+} | {
+    before: Date;
+} | {
+    after: Date;
+} | {
+    before: Date;
+    after: Date;
+} | DateRange;
+type DisabledProp = boolean | Date | Date[] | DisabledDateObject;
+type InputSize$2 = "xs" | "sm" | "md" | "lg";
+type DatePickerVariant$1 = "outlined" | "contained";
+interface DatePickerProps {
+    label?: string;
+    value?: Date;
+    onChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    required?: boolean;
+    description?: string;
+    error?: string;
+    disabled?: boolean;
+    variant?: DatePickerVariant$1;
+    isClerable?: boolean;
+    size?: InputSize$2;
+    className?: string;
+    disableRange?: DisabledProp;
+    floatingLabel?: boolean;
+}
+declare const DatePicker: React$1.FC<DatePickerProps>;
+
+type InputSize$1 = "xs" | "sm" | "md" | "lg";
+type DatePickerVariant = "outlined" | "contained";
+interface DateRangePickerProps {
+    label?: string;
+    value?: {
+        from: Date;
+        to: Date;
+    };
+    onChange?: (range: {
+        from: Date;
+        to: Date;
+    } | undefined) => void;
+    placeholder?: string;
+    required?: boolean;
+    description?: string;
+    error?: string;
+    disabled?: boolean;
+    variant?: DatePickerVariant;
+    size?: InputSize$1;
+    className?: string;
+    floatingLabel?: boolean;
+}
+declare const DateRangePicker: React$1.FC<DateRangePickerProps>;
+
+type FieldType = "text" | "number" | "textarea" | "select" | "multiselect" | "multi-select" | "timepicker" | "time" | "radio" | "switch" | "checkbox" | "date" | "daterange" | "file" | "custom";
+type FormField = {
+    name: string;
+    label: string;
+    type: FieldType;
+    placeholder?: string;
+    required?: boolean;
+    defaultValue?: any;
+    options?: {
+        label: string;
+        value: any;
+    }[];
+    validation?: any;
+    visibleIf?: (values: any) => boolean;
+    component?: React__default.ReactNode;
+    colSpan?: number;
+    inputProps?: Record<string, any>;
+    controllerProps?: Partial<React__default.ComponentProps<typeof Controller>>;
+};
+type FormProps = {
+    schema: FormField[];
+    form: UseFormReturn;
+    layout?: "vertical" | "grid";
+    columns?: number;
+    className?: string;
+    showSubmitButton?: boolean;
+    onSubmit?: (data: any) => void;
+};
+declare const Form: React__default.FC<FormProps>;
+
+type CheckboxSize = "sm" | "md" | "lg";
+interface CheckboxProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    size?: CheckboxSize;
+    indeterminate?: boolean;
+    error?: boolean;
+}
+declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface CheckboxGroupOption {
+    label: string;
+    value: string;
+    description?: string;
+    disabled?: boolean;
+}
+type Layout = "box" | "list";
+type Direction = "vertical" | "horizontal";
+interface CheckboxGroupProps {
+    name: string;
+    label?: string;
+    description?: string;
+    error?: boolean;
+    options: CheckboxGroupOption[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (selected: string[]) => void;
+    direction?: Direction;
+    layout?: Layout;
+    disabled?: boolean;
+    size?: CheckboxProps["size"];
+    className?: string;
+    columns?: number;
+}
+declare const CheckboxGroup: React$1.FC<CheckboxGroupProps>;
+
+interface RadioProps {
+    label?: string;
+    description?: string;
+    name?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    error?: boolean;
+    helperText?: string;
+    size?: 'small' | 'medium';
+    color?: 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
+    sx?: SxProps;
+    radioSx?: SxProps;
+    labelSx?: SxProps;
+}
+declare const Radio: React__default.ForwardRefExoticComponent<RadioProps & React__default.RefAttributes<HTMLDivElement>>;
+
+interface PopupConfirmProps {
+    open: boolean;
+    onClose: () => void;
+    title?: string | React__default.ReactNode;
+    message: string | React__default.ReactNode;
+    description?: string;
+    confirmText?: string;
+    cancelText?: string;
+    confirmVariant?: 'text' | 'outlined' | 'contained';
+    cancelVariant?: 'text' | 'outlined' | 'contained';
+    confirmColor?: 'primary' | 'secondary' | 'error' | 'warning' | 'info' | 'success';
+    cancelColor?: 'primary' | 'secondary' | 'error' | 'warning' | 'info' | 'success';
+    loading?: boolean;
+    loadingText?: string;
+    icon?: React__default.ReactNode;
+    maxWidth?: false | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    fullWidth?: boolean;
+    showCloseIcon?: boolean;
+    confirmSize?: 'small' | 'medium' | 'large';
+    cancelSize?: 'small' | 'medium' | 'large';
+    onConfirm: () => void | Promise<void>;
+    onCancel?: () => void;
+    children?: React__default.ReactNode;
+    className?: string;
+    actionsClassName?: string;
+    messageClassName?: string;
+    reverseActions?: boolean;
+    singleAction?: boolean;
+    variant?: 'default' | 'delete' | 'save' | 'warning' | 'info' | 'success' | 'error';
+}
+declare const PopupConfirm: React__default.FC<PopupConfirmProps>;
+
+type List = {
+    list: Record<string, any>[];
+};
+interface GlobalMenuSearchComponentProps extends List {
+    list: Record<string, any>[];
+    delay?: number;
+    placeholder?: string;
+    popInputPlaceholder?: string;
+    history: any;
+}
+declare const GlobalMenuSearch: React__default.FC<GlobalMenuSearchComponentProps>;
+
+type AppListItem = {
+    [key: string]: any;
+};
+interface AppListProps {
+    apps: AppListItem[];
+    icon?: ElementType;
+    urlKey?: string;
+    nameKey?: string;
+    appIconKey?: string;
+    iconProps?: object;
+    popoverProps?: object;
+    listProps?: object;
+    listItemProps?: object;
+    listItemTextProps?: object;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    padding?: number;
+    border?: boolean;
+    target?: '_blank' | '_self' | '_parent' | '_top' | 'framename';
+}
+declare const AppList: React__default.FC<AppListProps>;
+
+interface Column {
+    id: string;
+    header: string;
+    accessor: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    sticky?: 'left' | 'right';
+    sortable?: boolean;
+    filterable?: boolean;
+    hidden?: boolean;
+    align?: 'left' | 'center' | 'right';
+    render?: (value: any, row: any, index: number) => React__default.ReactNode;
+}
+interface TableData {
+    id: string;
+    [key: string]: any;
+    _expanded?: boolean;
+    _selected?: boolean;
+    _children?: TableData[];
+}
+interface StickyConfig {
+    left?: string[];
+    right?: string[];
+}
+interface BulkAction$1 {
+    label: string;
+    icon?: React__default.ReactNode;
+    onClick: (selectedIds: string[]) => void;
+    variant?: 'primary' | 'secondary' | 'danger';
+    disabled?: boolean;
+}
+interface TableProps {
+    columns: Column[];
+    data: TableData[];
+    loading?: boolean;
+    pagination?: {
+        page: number;
+        pageSize: number;
+        total: number;
+        onPageChange: (page: number) => void;
+        onPageSizeChange: (size: number) => void;
+    };
+    selection?: {
+        enabled: boolean;
+        selectedRows: string[];
+        onSelectionChange: (selectedIds: string[]) => void;
+    };
+    sorting?: {
+        sortBy: string;
+        sortOrder: 'asc' | 'desc';
+        onSortChange: (sortBy: string, order: 'asc' | 'desc') => void;
+    };
+    filtering?: {
+        filters: Record<string, any>;
+        onFilterChange: (filters: Record<string, any>) => void;
+    };
+    expansion?: {
+        expandedRows: string[];
+        onExpansionChange: (expandedIds: string[]) => void;
+        renderExpandedRow: (row: TableData) => React__default.ReactNode;
+    };
+    virtualization?: {
+        enabled: boolean;
+        rowHeight?: number;
+        overscan?: number;
+    };
+    onRowClick?: (row: TableData) => void;
+    className?: string;
+    stickyColumns?: StickyConfig;
+    bulkActions?: BulkAction$1[];
+    isRowSelectable?: (row: TableData) => boolean;
+    variant?: 'standard' | 'compact' | 'striped';
+}
+declare const Table: React__default.FC<TableProps>;
+
+interface BulkAction {
+    id: string;
+    label: string;
+    icon?: React__default.ReactNode;
+    onClick: (selectedIds: string[]) => void;
+    disabled?: boolean;
+    variant?: 'primary' | 'danger' | 'default';
+    type?: 'button' | 'dropdown';
+    onOpen?: () => void;
+}
+interface BulkActionsBarProps {
+    selectedRows: string[];
+    totalRows: number;
+    bulkActions: BulkAction[];
+    clearSelection: () => void;
+    maxVisibleActions?: number;
+}
+declare const BulkActionsBar: React__default.FC<BulkActionsBarProps>;
+
+type InputSize = 'xs' | 'sm' | 'md' | 'lg';
+type InputVariant = 'outlined' | 'contained';
+interface TimePickerProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'value' | 'defaultValue'> {
+    label?: string;
+    floatingLabel?: boolean;
+    description?: string;
+    error?: string;
+    size?: InputSize;
+    variant?: InputVariant;
+    focusOutline?: boolean;
+    value?: Dayjs | null;
+    defaultValue?: Dayjs | null;
+    onChange?: (time: Dayjs | null, timeString: string) => void;
+    format?: string;
+    use12Hours?: boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    needConfirm?: boolean;
+    showNow?: boolean;
+    okText?: string;
+    closeText?: string;
+    nowText?: string;
+    amText?: string;
+    pmText?: string;
+    hourLabel?: string;
+    minuteLabel?: string;
+    secondLabel?: string;
+    disabledHours?: (h: number) => boolean;
+    disabledMinutes?: (m: number) => boolean;
+    disabledSeconds?: (s: number) => boolean;
+    allowClear?: boolean;
+}
+declare const TimePicker: React$1.ForwardRefExoticComponent<TimePickerProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface BulkActionConfig {
+    key: string;
+    label: string;
+    icon: React__default.ComponentType<{
+        className?: string;
+    }>;
+    variant?: 'default' | 'destructive' | 'secondary';
+}
+interface PaginationConfig {
+    enabled?: boolean;
+    totalCount?: number;
+    currentPage?: number;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    initialPageSize?: number;
+    onPageChange?: (pageIndex: number, pageSize: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    showInfo?: boolean;
+    showPageSizeSelector?: boolean;
+    showGoToPage?: boolean;
+}
+interface SelectionConfig<TData> {
+    enabled?: boolean;
+    rowIdAccessor?: (row: TData) => string;
+    onBulkAction?: (ids: string[], action: string) => void;
+    bulkActions?: BulkActionConfig[];
+    selectionText?: (count: number) => string;
+}
+interface ExpandConfig<TData> {
+    enabled?: boolean;
+    renderExpanded?: (row: TData) => React__default.ReactNode;
+}
+interface SortingConfig {
+    enabled?: boolean;
+    initialSorting?: SortingState;
+    onSort?: (sorting: SortingState) => void;
+}
+interface LoadingConfig {
+    loading?: boolean;
+    fetched?: boolean;
+    loadingRows?: number;
+    emptyMessage?: string;
+}
+interface StylingConfig {
+    className?: string;
+    showColumnBorders?: boolean;
+    showRowBorders?: boolean;
+    stickyHeader?: boolean;
+    pinLeft?: number;
+    pinRight?: number;
+}
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    serverMode?: boolean;
+    pagination?: PaginationConfig;
+    selection?: SelectionConfig<TData>;
+    expansion?: ExpandConfig<TData>;
+    sorting?: SortingConfig;
+    loading?: LoadingConfig;
+    styling?: StylingConfig;
+}
+declare function DataTable<TData, TValue>({ columns, data, serverMode, pagination: paginationConfig, selection: selectionConfig, expansion: expansionConfig, sorting: sortingConfig, loading: loadingConfig, styling: stylingConfig, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+type TabVariant = 'default' | 'pills' | 'outline' | 'underline' | 'ghost' | 'bordered';
+type TabSize = 'sm' | 'md' | 'lg' | 'xl';
+interface TabProviderProps {
+    children: React__default.ReactNode;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    variant?: TabVariant;
+    size?: TabSize;
+    orientation?: 'horizontal' | 'vertical';
+}
+interface TabListProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+}
+interface TabTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+    icon?: LucideIcon;
+    iconPosition?: 'left' | 'right';
+    badge?: number | string;
+    badgeVariant?: 'default' | 'secondary' | 'success' | 'warning' | 'error';
+    loading?: boolean;
+    children: React__default.ReactNode;
+}
+interface TabContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    value: string;
+    children: React__default.ReactNode;
+    forceMount?: boolean;
+}
+declare const Tab: {
+    Provider: React__default.FC<TabProviderProps>;
+    List: React__default.FC<TabListProps>;
+    Trigger: React__default.FC<TabTriggerProps>;
+    Content: React__default.FC<TabContentProps>;
+};
+
+interface TimelineItem {
+    key?: string | number;
+    children?: ReactNode;
+    color?: 'blue' | 'green' | 'red' | 'gray' | 'yellow' | 'purple' | string;
+    dot?: ReactNode;
+    label?: ReactNode;
+    position?: 'left' | 'right';
+}
+interface TimelineProps {
+    items?: TimelineItem[];
+    children?: ReactNode;
+    pending?: boolean | ReactNode;
+    pendingDot?: ReactNode;
+    reverse?: boolean;
+    mode?: 'left' | 'right' | 'alternate';
+    className?: string;
+    style?: CSSProperties;
+}
+declare const Timeline: React__default.FC<TimelineProps>;
+
+interface UILibraryThemeProviderProps {
+    children: React__default.ReactNode;
+    primaryColor?: string;
+    secondaryColor?: string;
+    enableCssBaseline?: boolean;
+}
+declare const UILibraryThemeProvider: React__default.FC<UILibraryThemeProviderProps>;
+
+declare module '@mui/material/styles' {
+    interface Theme {
+        radius: {
+            xs: string;
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+            full: string;
+        };
+    }
+    interface ThemeOptions {
+        radius?: {
+            xs?: string;
+            sm?: string;
+            md?: string;
+            lg?: string;
+            xl?: string;
+            full?: string;
+        };
+    }
+}
+interface ThemeConfig {
+    primaryColor?: string;
+    secondaryColor?: string;
+}
+declare const createCustomTheme: (config?: ThemeConfig) => Theme;
+declare const theme: Theme;
+
+declare const designTokens: {
+    colors: {
+        primary: {
+            50: string;
+            100: string;
+            500: string;
+            900: string;
+        };
+        secondary: {
+            50: string;
+            100: string;
+            500: string;
+            900: string;
+        };
+        neutral: {
+            50: string;
+            100: string;
+            200: string;
+            500: string;
+            900: string;
+        };
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    radius: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        full: string;
+    };
+    typography: {
+        fontFamily: string;
+        fontSize: {
+            xs: string;
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+        };
+    };
+    size: {
+        small: string;
+        medium: string;
+        large: string;
+    };
+};
+
+declare function cn(...inputs: ClassValue[]): string;
+declare function useStableId(prefix?: string): string;
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, AppList, Badge, Blockquote, BulkActionsBar, Button, Caption, CardActions, CardContent, CardHeader, CardImage, CardRoot, CardSkeleton, Checkbox, CheckboxGroup, Code, DataTable, DatePicker, DateRangePicker, Drawer, Form, GlobalMenuSearch, Heading, Input, Lead, Modal, Muted, Notice, Popover, PopupConfirm, Radio, RadioGroup, Select, Strong, Switch, Tab, Table, Text, TimePicker, Timeline, UILibraryThemeProvider, cn, createCustomTheme, designTokens, theme, useStableId };
+export type { AccordionContentProps, AccordionItemProps, AccordionProps, AccordionTriggerProps, AppListProps, BadgeProps, BulkActionsBarProps, ButtonProps, CardRootProps, CheckboxGroupProps, CheckboxProps, DataTableProps, DatePickerProps, DateRangePickerProps, DrawerProps, FormProps, GlobalMenuSearchComponentProps, InputProps, ModalProps, NoticeProps, PopoverProps, PopupConfirmProps, RadioGroupProps, RadioOption, RadioProps, SelectProps, SwitchProps, TabSize, TabTriggerProps, TabVariant, TableProps, ThemeConfig, TimePickerProps, TimelineItem as TimelineItemProps, TimelineProps, UILibraryThemeProviderProps };