docthub-core-components 2.2.0 → 2.3.4

package/dist/src/components/overrides/ui/auto-complete.d.ts

@@ -42,6 +42,10 @@ interface AutocompleteProps<T> {
     emptyMessage?: string;
     className?: string;
     inputClassName?: string;
+    debounceMs?: number;
+    minSearchLength?: number;
+    /** Control built-in bolding of matched query segments (default: false) */
+    ntt?: boolean;
 }
-export declare const DoctAutocomplete: <T extends OptionType>({ options, dataSource, value, onChange, change, onInputChange, placeholder, multiple, freeSolo, disabled, loading, size, variant, label, helperText, error, required, fullWidth, clearable, disableCloseOnSelect, filterOptions, getOptionLabel, getOptionValue, isOptionEqualToValue, renderOption, renderTags, fields, noOptionsText, emptyMessage, className, inputClassName, ...props }: AutocompleteProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const DoctAutocomplete: <T extends OptionType>({ options, dataSource, value, onChange, change, onInputChange, placeholder, multiple, freeSolo, disabled, loading, size, variant, label, helperText, error, required, fullWidth, clearable, disableCloseOnSelect, filterOptions, getOptionLabel, getOptionValue, isOptionEqualToValue, renderOption, renderTags, fields, noOptionsText, emptyMessage, className, inputClassName, debounceMs, minSearchLength, ntt, ...props }: AutocompleteProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/overrides/ui/autocomplete-checkbox.d.ts

@@ -0,0 +1,44 @@
+import { default as React } from 'react';
+import { OptionType } from '../../../hooks/useAutocompleteCheckbox';
+export interface AutocompleteCheckboxProps<T = unknown> {
+    options: T[];
+    value?: T[];
+    onChange?: (event: React.SyntheticEvent | null, value: T[]) => void;
+    onInputChange?: (event: React.ChangeEvent<HTMLInputElement>, value: string) => void;
+    placeholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    noOptionsText?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    disableCloseOnSelect?: boolean;
+    freeSolo?: T extends string ? boolean : never;
+    size?: "small" | "medium" | "large";
+    variant?: "outlined" | "filled" | "standard";
+    fullWidth?: boolean;
+    className?: string;
+    inputClassName?: string;
+    getOptionLabel?: (option: T) => string;
+    getOptionValue?: (option: T) => string | T;
+    isOptionEqualToValue?: (option: T, value: T) => boolean;
+    filterOptions?: (options: T[], state: {
+        inputValue: string;
+    }) => T[];
+    renderOption?: (option: T, index: number) => React.ReactNode;
+    renderTags?: (value: T[], handleTagRemove: (tag: T) => void) => React.ReactNode;
+    limitTags?: number;
+    fields?: {
+        value: string | number;
+        text: string;
+    };
+    dataSource?: T[];
+    change?: (event: {
+        itemData: T[];
+    }) => void;
+}
+export declare function AutocompleteCheckbox<T extends OptionType>({ options, dataSource, value, onChange, change, onInputChange, placeholder, label, helperText, error, noOptionsText, emptyMessage, disabled, loading, required, clearable, disableCloseOnSelect, freeSolo, size, variant, fullWidth, className, inputClassName, getOptionLabel, getOptionValue, isOptionEqualToValue, filterOptions, renderOption, renderTags, limitTags, fields, }: AutocompleteCheckboxProps<T>): import("react/jsx-runtime").JSX.Element;
+export default AutocompleteCheckbox;

package/dist/src/components/overrides/ui/chips/doct-chip.d.ts

@@ -1,16 +1,22 @@
-import { ReactNode, MouseEvent, FC } from 'react';
+import { ReactNode, MouseEvent, KeyboardEvent, FC } from 'react';
 export interface ChipProps {
     label: string;
-    variant?: "filled" | "outlined";
+    variant?: "filled" | "outlined" | "soft";
     color?: "default" | "primary" | "secondary" | "success" | "warning" | "error";
     size?: "small" | "medium" | "large";
+    /** Chip corner style */
+    shape?: "pill" | "square";
     deletable?: boolean;
-    onDelete?: (e: MouseEvent<HTMLButtonElement>) => void;
-    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    onDelete?: (e: MouseEvent<HTMLButtonElement> | KeyboardEvent<HTMLButtonElement>) => void;
+    onClick?: (e: MouseEvent<HTMLDivElement> | KeyboardEvent<HTMLDivElement>) => void;
     icon?: ReactNode;
     avatar?: ReactNode | string;
     disabled?: boolean;
     className?: string;
+    /** ARIA label for the chip */
+    "aria-label"?: string;
+    /** ARIA label for the delete button */
+    deleteAriaLabel?: string;
 }
 export declare const Chip: FC<ChipProps>;
 export interface ChipsContainerProps {

package/dist/src/components/overrides/ui/expandable-card.d.ts

@@ -4,9 +4,14 @@ interface ExpandableCardProps {
     title: React.ReactNode;
     content: React.ReactNode;
     defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
     className?: string;
     titleTypographyProps?: Partial<DoctTypographyProps>;
     contentTypographyProps?: Partial<DoctTypographyProps>;
+    animationDuration?: number;
+    disabled?: boolean;
+    clickableArea?: "full" | "header" | "button";
 }
-export declare function ExpandableCard({ title, content, defaultOpen, className, titleTypographyProps, contentTypographyProps, }: ExpandableCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function ExpandableCard({ title, content, defaultOpen, open: controlledOpen, onOpenChange, className, titleTypographyProps, contentTypographyProps, animationDuration, disabled, clickableArea, }: ExpandableCardProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/overrides/ui/inputs/labeled-input.d.ts

@@ -1,21 +1,26 @@
 import { FC, ReactNode } from 'react';
-interface LabeledInputProps extends React.HTMLAttributes<HTMLInputElement> {
+interface LabeledInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
     label?: string;
     placeholder?: string;
     helperText?: string;
     error?: string;
     required?: boolean;
-    type?: "text" | "email" | "password" | "number" | "tel";
+    type?: "text" | "email" | "password" | "number" | "tel" | "url" | "search";
     leftIcon?: ReactNode;
     rightIcon?: ReactNode;
     className?: string;
     inputClassName?: string;
     onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onValueChange?: (value: string) => void;
     showCharCount?: boolean;
     maxLength?: number;
-    value?: string;
+    characterLimit?: number;
     disabled?: boolean;
+    readOnly?: boolean;
+    /** @deprecated Use `readOnly` instead. Will be removed in v3.0 */
     fridged?: boolean;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
 }
 export declare const LabeledInput: FC<LabeledInputProps>;
 export {};

package/dist/src/components/overrides/ui/inputs/otp-input.d.ts

@@ -7,6 +7,10 @@ interface OtpInputProps {
     className?: string;
     error?: string;
     inputClassName?: string;
+    autoFocus?: boolean;
+    autoSubmit?: boolean;
+    secure?: boolean;
+    "aria-label"?: string;
 }
 export declare const OtpInput: React.FC<OtpInputProps>;
 export {};

package/dist/src/components/overrides/ui/inputs/password-input.d.ts

@@ -1,4 +1,4 @@
-interface PasswordInputProps extends Omit<React.HTMLAttributes<HTMLInputElement>, 'onChange'> {
+interface PasswordInputProps extends Omit<React.HTMLAttributes<HTMLInputElement>, "onChange"> {
     label?: string;
     placeholder?: string;
     helperText?: string;
@@ -9,6 +9,10 @@ interface PasswordInputProps extends Omit<React.HTMLAttributes<HTMLInputElement>
     onShowPasswordChange?: (show: boolean) => void;
     value?: string;
     onChange?: (value: string) => void;
+    onChangeEvent?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onValueChange?: (value: string) => void;
+    autoComplete?: string;
+    "aria-label"?: string;
 }
-export declare function PasswordInput({ label, placeholder, helperText, error, required, className, showPassword, onShowPasswordChange, value, onChange, ...restProps }: PasswordInputProps): import("react/jsx-runtime").JSX.Element;
+export declare function PasswordInput({ label, placeholder, helperText, error, required, className, showPassword, onShowPasswordChange, value, onChange, onChangeEvent, onValueChange, autoComplete, ...restProps }: PasswordInputProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/overrides/ui/pickers/date-picker-field.d.ts

@@ -1,30 +1,30 @@
 import { DayPickerSingleProps } from 'react-day-picker';
 import * as React from "react";
-/**
- * DatePickerFieldProps supports all custom props and extra DayPicker props via dayPickerProps.
- * - All custom props are explicit.
- * - Extra DayPicker props can be passed via ...dayPickerProps.
- * - All extra HTML div props can be passed via ...rest.
- */
-export interface DatePickerFieldProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+export type DateFormat = "MM/DD/YYYY" | "DD/MM/YYYY" | "YYYY-MM-DD" | "DD-MM-YYYY";
+export interface DatePickerFieldProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect" | "onChange"> {
     label?: string;
     placeholder?: string;
     helperText?: string;
-    error?: string;
     required?: boolean;
     value?: Date;
     onSelect?: (date: Date | undefined) => void;
+    onChange?: (date: Date | undefined) => void;
     className?: string;
     minDate?: Date;
     maxDate?: Date;
     disabled?: boolean;
     readOnly?: boolean;
     locale?: string;
+    dateFormat?: DateFormat;
+    inputClassName?: string;
+    error?: string;
     showOutsideDays?: boolean;
-    dayPickerProps?: Partial<DayPickerSingleProps>;
+    clearable?: boolean;
     month?: Date;
     onMonthChange?: (month: Date) => void;
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
+    dayPickerProps?: Partial<DayPickerSingleProps>;
+    manual?: boolean;
 }
 export declare const DatePickerField: React.FC<DatePickerFieldProps>;

package/dist/src/components/overrides/ui/pickers/select-field.d.ts

@@ -2,21 +2,30 @@ import { ReactNode } from 'react';
 interface SelectOption {
     value: string;
     label: string;
+    disabled?: boolean;
+    group?: string;
 }
 interface SelectFieldProps {
     label?: string;
     placeholder?: string;
     options: SelectOption[];
     value?: string;
+    onValueChange?: (value: string) => void;
+    onChange?: (value: string) => void;
     leadingIcon?: ReactNode;
+    trailingIcon?: ReactNode;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
     helperText?: string;
     error?: string;
     required?: boolean;
-    onValueChange?: (value: string) => void;
-    className?: string;
-    variant?: "default" | "gray";
     disabled?: boolean;
+    loading?: boolean;
     clearable?: boolean;
+    className?: string;
+    variant?: "default" | "gray";
+    "aria-label"?: string;
+    "aria-describedby"?: string;
 }
-export declare function SelectField({ label, placeholder, options, value, leadingIcon, helperText, error, required, onValueChange, className, variant, disabled, clearable, }: SelectFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function SelectField({ label, placeholder, options, value, onValueChange, onChange, leadingIcon, trailingIcon, startIcon, endIcon, helperText, error, required, disabled, loading, clearable, className, variant, }: SelectFieldProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/ui/alert.d.ts

@@ -1,8 +1,19 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
-declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
-    variant?: "default" | "destructive" | null | undefined;
-} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const alertVariants: (props?: ({
+    variant?: "default" | "error" | "success" | "warning" | "destructive" | "info" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    /** Custom icon to display. Set to false to hide icon. */
+    icon?: React.ReactNode | false;
+    /** Callback when alert is dismissed */
+    onClose?: () => void;
+    /** Custom action element (e.g., button) */
+    action?: React.ReactNode;
+    /** Alias for variant (MUI compatibility) */
+    severity?: VariantProps<typeof alertVariants>["variant"];
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
 declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
 declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
 export { Alert, AlertTitle, AlertDescription };

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

@@ -1,6 +1,12 @@
-import { Avatar as AvatarPrimitive } from 'radix-ui';
+import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
-declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
 declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
 declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
 export { Avatar, AvatarImage, AvatarFallback };

package/dist/src/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/src/components/ui/button.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import { default as React } from 'react';
 declare const DoctButtonVariants: (props?: ({
-    variant?: "default" | "outline" | "ghost" | "error" | "success" | "warning" | "blue" | "disabled" | "brandBlue" | "primary" | null | undefined;
+    variant?: "default" | "outline" | "ghost" | "error" | "success" | "warning" | "blue" | "disabled" | "brandBlue" | "primary" | "namya" | null | undefined;
     size?: "small" | "large" | "medium" | "icon.large" | "icon.medium" | "icon.small" | null | undefined;
     iconSize?: "small" | "large" | "medium" | null | undefined;
     iconPosition?: "left" | "right" | null | undefined;

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

@@ -1,5 +1,5 @@
-import { Checkbox as CheckboxPrimitive } from 'radix-ui';
 import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
 export interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
     color?: string;
 }

package/dist/src/components/ui/dialog.d.ts

@@ -5,8 +5,26 @@ declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.Dia
 declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
 declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
 declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sizeClasses: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    full: string;
+};
 declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    /** Close dialog when clicking outside */
     closeOnOutsideClick?: boolean;
+    /** Initial focus element ref */
+    initialFocusRef?: React.RefObject<HTMLElement>;
+    /** Size preset */
+    size?: keyof typeof sizeClasses;
+    /** Show close button */
+    showCloseButton?: boolean;
+    /** Close on Escape key */
+    closeOnEscape?: boolean;
 } & React.RefAttributes<HTMLDivElement>>;
 declare const DialogHeader: {
     ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;

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

@@ -1,4 +1,4 @@
-import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
 import * as React from "react";
 declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
 declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;

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

@@ -1,3 +1,7 @@
 import * as React from "react";
-declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export interface InputProps extends React.ComponentProps<"input"> {
+    error?: boolean;
+    hasError?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 export { Input };

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

@@ -1,5 +1,5 @@
-import { Label as LabelPrimitive } from 'radix-ui';
 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/src/components/ui/popover.d.ts

@@ -1,5 +1,5 @@
-import { Popover as PopoverPrimitive } from 'radix-ui';
 import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
 declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
 declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
 declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -1,4 +1,22 @@
-import { Progress as ProgressPrimitive } from 'radix-ui';
 import * as React from "react";
-declare const Progress: React.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+import * as ProgressPrimitive from "@radix-ui/react-progress";
+type ColorVariant = "primary" | "secondary" | "success" | "error" | "warning" | "info";
+type ProgressVariant = "determinate" | "indeterminate" | "buffer" | "query";
+export interface ProgressProps extends Omit<React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>, "color"> {
+    /** Progress value between 0-100 */
+    value?: number;
+    /** Buffer value for buffer variant (0-100) */
+    valueBuffer?: number;
+    /** Progress variant */
+    variant?: ProgressVariant;
+    /** Color variant or custom color */
+    color?: ColorVariant | string;
+    /** Custom color (overrides color variant) */
+    customColor?: string;
+    /** Show percentage label */
+    showLabel?: boolean;
+    /** Custom label text or formatter function */
+    label?: string | ((value: number) => string);
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
 export { Progress };

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

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

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

@@ -1,5 +1,5 @@
-import { Select as SelectPrimitive } from 'radix-ui';
 import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
 declare const Select: React.FC<SelectPrimitive.SelectProps>;
 declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
 declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;

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

@@ -1,2 +1,15 @@
-declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+import * as React from "react";
+type SkeletonVariant = "text" | "circular" | "rectangular" | "rounded";
+type SkeletonAnimation = "pulse" | "wave" | "none";
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Shape variant */
+    variant?: SkeletonVariant;
+    /** Animation type */
+    animation?: SkeletonAnimation | false;
+    /** Width (CSS value or number for pixels) */
+    width?: number | string;
+    /** Height (CSS value or number for pixels) */
+    height?: number | string;
+}
+declare function Skeleton({ className, variant, animation, width, height, style, ...props }: SkeletonProps): import("react/jsx-runtime").JSX.Element;
 export { Skeleton };

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

@@ -1,7 +1,12 @@
-import { Tabs as TabsPrimitive } from 'radix-ui';
 import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
 declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
-declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: "default" | "custom";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    variant?: "default" | "custom";
+    showSeparator?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
 declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { Tabs, TabsList, TabsTrigger, TabsContent };

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

@@ -3,7 +3,12 @@ export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextArea
     label?: string;
     helperText?: string;
     errorText?: string;
+    error?: string;
     required?: boolean;
+    resize?: "none" | "vertical" | "horizontal" | "both";
+    showCharCount?: boolean;
+    characterLimit?: number;
+    onValueChange?: (value: string) => void;
 }
 declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
 export { Textarea };

package/dist/src/components/ui/timeline.d.ts

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export interface TimelineItem {
+    id: string;
+    title: string;
+    subtitle?: string;
+    date?: string;
+    status?: "completed" | "pending" | "current";
+    description?: string;
+}
+declare const lineClasses: (props?: ({
+    thickness?: "normal" | "thick" | "thin" | null | undefined;
+    inset?: "none" | "sm" | "md" | "lg" | null | undefined;
+    offset?: "sm" | "md" | "lg" | null | undefined;
+    color?: "primary" | "gray" | "teal" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const dotClasses: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    offset?: "sm" | "md" | "lg" | null | undefined;
+    color?: "primary" | "gray" | "teal" | null | undefined;
+    y?: "base" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const itemsGapClasses: (props?: ({
+    density?: "compact" | "comfortable" | "card" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const indentClasses: (props?: ({
+    indent?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TimelineProps extends VariantProps<typeof lineClasses>, VariantProps<typeof dotClasses>, VariantProps<typeof itemsGapClasses>, VariantProps<typeof indentClasses> {
+    items: TimelineItem[];
+    title?: string;
+    className?: string;
+    showStatus?: boolean;
+    variant?: "default" | "minimal" | "card";
+    /** Convenience alias: sets both line and dot color. */
+    color?: "teal" | "gray" | "primary";
+    /** Content indent relative to the dot/line. */
+    indent?: "sm" | "md" | "lg";
+}
+declare const Timeline: React.ForwardRefExoticComponent<TimelineProps & React.RefAttributes<HTMLDivElement>>;
+export { Timeline };

package/dist/src/components/ui/tooltip.d.ts

@@ -1,7 +1,11 @@
-import { Tooltip as TooltipPrimitive } from 'radix-ui';
 import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
 declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
 declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
 declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    /** Whether to show the arrow pointer */
+    showArrow?: boolean;
+}
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
 export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/src/components/ui/typography.d.ts

@@ -1,11 +1,13 @@
 import { default as React } from 'react';
-export interface DoctTypographyProps {
+export interface DoctTypographyProps extends React.HTMLAttributes<HTMLElement> {
     variant: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "h7" | "h8" | "title1" | "title2" | "title3" | "title4" | "body1" | "body2" | "body3" | "body4" | "textLabel1" | "textLabel2" | "textLabel3" | "textLabel4";
     weight?: "regular" | "medium" | "semiBold" | "bold" | "extraBold" | "light";
     children: React.ReactNode;
     color?: string;
     align?: "inherit" | "left" | "center" | "right" | "justify";
     className?: string;
+    /** HTML element to render as */
+    as?: React.ElementType;
 }
 declare const DoctTypography: React.FC<DoctTypographyProps>;
 export { DoctTypography };

package/dist/src/hooks/useAutocompleteCheckbox.d.ts

@@ -0,0 +1,55 @@
+export interface UseAutocompleteCheckboxOptions<T> {
+    options: T[];
+    value?: T[];
+    onChange?: (event: React.SyntheticEvent | null, value: T[]) => void;
+    onInputChange?: (event: React.ChangeEvent<HTMLInputElement>, value: string) => void;
+    disabled?: boolean;
+    disableCloseOnSelect?: boolean;
+    freeSolo?: T extends string ? boolean : never;
+    getOptionLabel?: (option: T) => string;
+    getOptionValue?: (option: T) => string | T;
+    isOptionEqualToValue?: (option: T, value: T) => boolean;
+    filterOptions?: (options: T[], state: {
+        inputValue: string;
+    }) => T[];
+    fields?: {
+        value: string | number;
+        text: string;
+    };
+}
+export interface UseAutocompleteCheckboxReturn<T> {
+    open: boolean;
+    inputValue: string;
+    highlightedIndex: number;
+    filteredOptions: T[];
+    selectedOptions: T[];
+    dropdownPosition: {
+        top: number;
+        left: number;
+        width: number;
+    };
+    inputRef: React.RefObject<HTMLInputElement | null>;
+    listRef: React.RefObject<HTMLDivElement | null>;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    setOpen: (open: boolean) => void;
+    setInputValue: (value: string) => void;
+    setHighlightedIndex: (index: number) => void;
+    handleInputChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    handleOptionSelect: (option: T) => void;
+    handleTagRemove: (tag: T) => void;
+    handleClear: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    handleClearAll: () => void;
+    handleKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    handleToggle: () => void;
+    handleFocus: () => void;
+    updateDropdownPosition: () => void;
+    isOptionSelected: (option: T) => boolean;
+    getOptionLabelSafe: (option: T) => string;
+    memoizedIsOptionEqualToValue: (option: T, value: T) => boolean;
+}
+export type OptionType = string | {
+    label: string;
+    value: string;
+} | Record<string, unknown>;
+export declare function useAutocompleteCheckbox<T extends OptionType>({ options, value, onChange, onInputChange, disabled, disableCloseOnSelect, freeSolo, getOptionLabel, getOptionValue, isOptionEqualToValue, filterOptions, fields, }: UseAutocompleteCheckboxOptions<T>): UseAutocompleteCheckboxReturn<T>;
+export default useAutocompleteCheckbox;