@mithunsalinda/veyqor-ui 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1029 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ImgHTMLAttributes, ButtonHTMLAttributes, Ref, InputHTMLAttributes, FocusEventHandler, ChangeEventHandler, FieldsetHTMLAttributes, ReactElement, CSSProperties, TableHTMLAttributes, TdHTMLAttributes, ThHTMLAttributes, AnchorHTMLAttributes } from 'react';
+import * as _base_ui_react from '@base-ui/react';
+import { ToastObject, UseToastManagerReturnValue, ToastManagerAddOptions, ToastManagerPromiseOptions, ToastManagerUpdateOptions, Toast } from '@base-ui/react/toast';
+
+interface AccordionItem {
+    value: string;
+    title: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+type AccordionSize = "sm" | "md";
+type AccordionVariant = "plain" | "outlined";
+interface AccordionProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    items: AccordionItem[];
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    multiple?: boolean;
+    disabled?: boolean;
+    keepMounted?: boolean;
+    size?: AccordionSize;
+    variant?: AccordionVariant;
+}
+
+declare const Accordion: react.ForwardRefExoticComponent<AccordionProps & react.RefAttributes<HTMLDivElement>>;
+
+type AlertIntent = "neutral" | "info" | "success" | "warning" | "danger";
+type AlertVariant = "soft" | "outline";
+interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    title?: ReactNode;
+    children?: ReactNode;
+    intent?: AlertIntent;
+    variant?: AlertVariant;
+    icon?: ReactNode;
+    action?: ReactNode;
+    dismissible?: boolean;
+    closeLabel?: string;
+    onDismiss?: () => void;
+}
+
+declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
+
+type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";
+type AvatarShape = "circle" | "rounded";
+interface AvatarProps extends Omit<HTMLAttributes<HTMLSpanElement>, "children"> {
+    name?: string;
+    src?: string;
+    alt?: string;
+    initials?: string;
+    fallback?: ReactNode;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    status?: ReactNode;
+    fallbackDelay?: number;
+    imageProps?: Omit<ImgHTMLAttributes<HTMLImageElement>, "alt" | "src">;
+    onLoadingStatusChange?: (status: "idle" | "loading" | "loaded" | "error") => void;
+}
+
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLSpanElement>>;
+
+type ButtonVariant = "primary" | "secondary" | "outline" | "ghost" | "destructive";
+type ButtonSize = "sm" | "md" | "lg";
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    loading?: boolean;
+    loadingLabel?: string;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+}
+
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+type BadgeIntent = "neutral" | "info" | "success" | "warning" | "danger";
+type BadgeVariant = "soft" | "solid" | "outline";
+type BadgeSize = "sm" | "md";
+type BadgeShape = "rounded" | "pill";
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    children?: ReactNode;
+    intent?: BadgeIntent;
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    shape?: BadgeShape;
+    dot?: boolean;
+    count?: number;
+    max?: number;
+    showZero?: boolean;
+    ariaLabel?: string;
+}
+
+declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface BreadcrumbItem {
+    label: ReactNode;
+    href?: string;
+    current?: boolean;
+    disabled?: boolean;
+}
+type BreadcrumbSize = "sm" | "md";
+interface BreadcrumbProps extends HTMLAttributes<HTMLElement> {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+    size?: BreadcrumbSize;
+    maxItems?: number;
+}
+
+declare const Breadcrumb: react.ForwardRefExoticComponent<BreadcrumbProps & react.RefAttributes<HTMLElement>>;
+
+type CardVariant = "surface" | "outlined" | "elevated";
+type CardPadding = "none" | "sm" | "md" | "lg";
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: CardVariant;
+    padding?: CardPadding;
+    interactive?: boolean;
+}
+type CardSectionProps = HTMLAttributes<HTMLDivElement>;
+type CardMediaProps = HTMLAttributes<HTMLDivElement>;
+type CardTitleProps = HTMLAttributes<HTMLHeadingElement>;
+type CardDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: react.ForwardRefExoticComponent<CardSectionProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: react.ForwardRefExoticComponent<CardTitleProps & react.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: react.ForwardRefExoticComponent<CardDescriptionProps & react.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: react.ForwardRefExoticComponent<CardSectionProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: react.ForwardRefExoticComponent<CardSectionProps & react.RefAttributes<HTMLDivElement>>;
+declare const CardMedia: react.ForwardRefExoticComponent<CardMediaProps & react.RefAttributes<HTMLDivElement>>;
+
+interface CheckboxProps {
+    id?: string;
+    name?: string;
+    value?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    label?: ReactNode;
+    description?: ReactNode;
+    className?: string;
+    onCheckedChange?: (checked: boolean) => void;
+}
+
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLSpanElement>>;
+
+type CollapsibleSize = "sm" | "md";
+type CollapsibleVariant = "plain" | "outlined";
+interface CollapsibleProps extends Omit<HTMLAttributes<HTMLDivElement>, "content" | "title"> {
+    title: ReactNode;
+    content: ReactNode;
+    description?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    keepMounted?: boolean;
+    hiddenUntilFound?: boolean;
+    size?: CollapsibleSize;
+    variant?: CollapsibleVariant;
+}
+
+declare const Collapsible: react.ForwardRefExoticComponent<CollapsibleProps & react.RefAttributes<HTMLDivElement>>;
+
+type ComboboxSize = "sm" | "md" | "lg";
+interface ComboboxOption {
+    value: string;
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    textValue?: string;
+}
+interface ComboboxProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    options: ComboboxOption[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (value: string) => void;
+    label?: string;
+    description?: string;
+    error?: string;
+    placeholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    name?: string;
+    id?: string;
+    inputRef?: Ref<HTMLInputElement>;
+    comboboxSize?: ComboboxSize;
+    clearLabel?: string;
+    openLabel?: string;
+}
+
+declare const Combobox: react.ForwardRefExoticComponent<ComboboxProps & react.RefAttributes<HTMLDivElement>>;
+
+type DialogSize = "sm" | "md" | "lg";
+interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    trigger?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    size?: DialogSize;
+    modal?: boolean | "trap-focus";
+    disablePointerDismissal?: boolean;
+    showCloseButton?: boolean;
+    closeLabel?: string;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare const Dialog: react.ForwardRefExoticComponent<DialogProps & react.RefAttributes<HTMLDivElement>>;
+
+type CommandSize = "sm" | "md";
+interface CommandAction {
+    id: string;
+    label: ReactNode;
+    description?: ReactNode;
+    keywords?: string[];
+    shortcut?: ReactNode;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface CommandGroup {
+    heading?: ReactNode;
+    actions: CommandAction[];
+}
+interface CommandProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    groups: CommandGroup[];
+    ariaLabel?: string;
+    defaultQuery?: string;
+    emptyMessage?: ReactNode;
+    inputLabel?: string;
+    onActionSelect?: (action: CommandAction) => void;
+    onQueryChange?: (query: string) => void;
+    placeholder?: string;
+    query?: string;
+    size?: CommandSize;
+}
+interface CommandDialogProps extends Omit<CommandProps, "className" | "title">, Pick<DialogProps, "closeLabel" | "defaultOpen" | "description" | "disablePointerDismissal" | "modal" | "onOpenChange" | "open" | "showCloseButton" | "title" | "trigger" | "triggerClassName"> {
+    className?: string | undefined;
+    contentClassName?: string | undefined;
+}
+
+declare const Command: react.ForwardRefExoticComponent<CommandProps & react.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: react.ForwardRefExoticComponent<CommandDialogProps & react.RefAttributes<HTMLDivElement>>;
+
+type ContextMenuAlign = "start" | "center" | "end";
+type ContextMenuSide = "top" | "right" | "bottom" | "left";
+type ContextMenuSize = "sm" | "md";
+type ContextMenuItem = {
+    type?: "item";
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    destructive?: boolean;
+    closeOnClick?: boolean;
+    onSelect?: () => void;
+} | {
+    type: "link";
+    label: ReactNode;
+    description?: ReactNode;
+    href: string;
+    closeOnClick?: boolean;
+} | {
+    type: "separator";
+};
+interface ContextMenuProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    align?: ContextMenuAlign;
+    children?: ReactNode;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    items: ContextMenuItem[];
+    loopFocus?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    showArrow?: boolean;
+    side?: ContextMenuSide;
+    sideOffset?: number;
+    size?: ContextMenuSize;
+    triggerClassName?: string;
+}
+
+declare const ContextMenu: react.ForwardRefExoticComponent<ContextMenuProps & react.RefAttributes<HTMLDivElement>>;
+
+type DatePickerSize = "sm" | "md" | "lg";
+interface DatePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "aria-describedby" | "aria-invalid" | "children" | "className" | "onChange" | "size" | "type"> {
+    className?: string;
+    datePickerSize?: DatePickerSize;
+    description?: ReactNode;
+    error?: ReactNode;
+    inputClassName?: string;
+    invalid?: boolean;
+    label?: ReactNode;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (value: string) => void;
+    clearLabel?: string;
+    showClearButton?: boolean;
+}
+
+declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLInputElement>>;
+
+type DropdownMenuAlign = "start" | "center" | "end";
+type DropdownMenuSide = "top" | "right" | "bottom" | "left";
+type DropdownMenuSize = "sm" | "md";
+type DropdownMenuItem = {
+    type?: "item";
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    destructive?: boolean;
+    closeOnClick?: boolean;
+    onSelect?: () => void;
+} | {
+    type: "link";
+    label: ReactNode;
+    description?: ReactNode;
+    href: string;
+    closeOnClick?: boolean;
+} | {
+    type: "separator";
+};
+interface DropdownMenuProps extends HTMLAttributes<HTMLDivElement> {
+    trigger: ReactNode;
+    items: DropdownMenuItem[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    modal?: boolean;
+    loopFocus?: boolean;
+    align?: DropdownMenuAlign;
+    side?: DropdownMenuSide;
+    sideOffset?: number;
+    size?: DropdownMenuSize;
+    showArrow?: boolean;
+    triggerClassName?: string;
+}
+
+declare const DropdownMenu: react.ForwardRefExoticComponent<DropdownMenuProps & react.RefAttributes<HTMLDivElement>>;
+
+type DrawerSide = "top" | "right" | "bottom" | "left";
+type DrawerSize = "sm" | "md" | "lg" | "full";
+interface DrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    trigger?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    side?: DrawerSide;
+    size?: DrawerSize;
+    modal?: boolean | "trap-focus";
+    disablePointerDismissal?: boolean;
+    showCloseButton?: boolean;
+    closeLabel?: string;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>>;
+
+type EmptyStateAlign = "start" | "center";
+type EmptyStateDensity = "compact" | "comfortable";
+type EmptyStateTone = "neutral" | "info" | "success" | "warning" | "danger";
+interface EmptyStateProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    title: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    media?: ReactNode;
+    action?: ReactNode;
+    secondaryAction?: ReactNode;
+    align?: EmptyStateAlign;
+    as?: "section" | "div";
+    density?: EmptyStateDensity;
+    tone?: EmptyStateTone;
+}
+
+declare const EmptyState: react.ForwardRefExoticComponent<EmptyStateProps & react.RefAttributes<HTMLElement>>;
+
+type FieldsetDensity = "compact" | "comfortable";
+type FieldsetVariant = "plain" | "outlined" | "filled";
+interface FieldsetProps extends Omit<FieldsetHTMLAttributes<HTMLFieldSetElement>, "children"> {
+    children?: ReactNode;
+    description?: ReactNode;
+    density?: FieldsetDensity;
+    error?: ReactNode;
+    legend: ReactNode;
+    required?: boolean;
+    variant?: FieldsetVariant;
+}
+
+declare const Fieldset: react.ForwardRefExoticComponent<FieldsetProps & react.RefAttributes<HTMLFieldSetElement>>;
+
+interface FormFieldControlProps {
+    id?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "false" | "true";
+    invalid?: boolean;
+}
+interface FormFieldProps {
+    children: ReactElement<FormFieldControlProps>;
+    id?: string;
+    label: ReactNode;
+    description?: ReactNode;
+    error?: ReactNode;
+    required?: boolean;
+    className?: string;
+}
+
+declare function FormField({ children, className, description, error, id, label, required, }: FormFieldProps): react.JSX.Element;
+
+type InputSize = "sm" | "md" | "lg";
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    inputSize?: InputSize;
+    invalid?: boolean;
+}
+
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+type MenubarAlign = "start" | "center" | "end";
+type MenubarOrientation = "horizontal" | "vertical";
+type MenubarSize = "sm" | "md";
+type MenubarMenuItem = {
+    type?: "item";
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    destructive?: boolean;
+    closeOnClick?: boolean;
+    onSelect?: () => void;
+} | {
+    type: "link";
+    label: ReactNode;
+    description?: ReactNode;
+    href: string;
+    closeOnClick?: boolean;
+} | {
+    type: "separator";
+};
+interface MenubarMenu {
+    label: ReactNode;
+    items: MenubarMenuItem[];
+    disabled?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface MenubarProps extends HTMLAttributes<HTMLDivElement> {
+    menus: MenubarMenu[];
+    align?: MenubarAlign;
+    disabled?: boolean;
+    loopFocus?: boolean;
+    modal?: boolean;
+    orientation?: MenubarOrientation;
+    popupClassName?: string;
+    showArrow?: boolean;
+    sideOffset?: number;
+    size?: MenubarSize;
+}
+
+declare const Menubar: react.ForwardRefExoticComponent<MenubarProps & react.RefAttributes<HTMLDivElement>>;
+
+type NavigationMenuAlign = "start" | "center" | "end";
+type NavigationMenuOrientation = "horizontal" | "vertical";
+type NavigationMenuSide = "top" | "right" | "bottom" | "left";
+type NavigationMenuSize = "sm" | "md";
+interface NavigationMenuLinkItem {
+    label: ReactNode;
+    href: string;
+    description?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    closeOnClick?: boolean;
+}
+interface NavigationMenuFeaturedItem {
+    label: ReactNode;
+    href: string;
+    description?: ReactNode;
+    eyebrow?: ReactNode;
+}
+type NavigationMenuItem = {
+    type?: "link";
+    label: ReactNode;
+    href: string;
+    active?: boolean;
+    disabled?: boolean;
+} | {
+    type: "section";
+    label: ReactNode;
+    value: string;
+    links: NavigationMenuLinkItem[];
+    featured?: NavigationMenuFeaturedItem;
+    disabled?: boolean;
+};
+interface NavigationMenuProps extends Omit<HTMLAttributes<HTMLElement>, "defaultValue"> {
+    items: NavigationMenuItem[];
+    align?: NavigationMenuAlign;
+    closeDelay?: number;
+    defaultValue?: string | null;
+    delay?: number;
+    onValueChange?: (value: string | null) => void;
+    orientation?: NavigationMenuOrientation;
+    popupClassName?: string;
+    showArrow?: boolean;
+    side?: NavigationMenuSide;
+    sideOffset?: number;
+    size?: NavigationMenuSize;
+    value?: string | null;
+}
+
+declare const NavigationMenu: react.ForwardRefExoticComponent<NavigationMenuProps & react.RefAttributes<HTMLElement>>;
+
+type NumberFieldSize = "sm" | "md" | "lg";
+interface NumberFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    value?: number | null;
+    defaultValue?: number;
+    onValueChange?: (value: number | null) => void;
+    onValueCommitted?: (value: number | null) => void;
+    label?: string;
+    description?: string;
+    error?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    min?: number;
+    max?: number;
+    step?: number | "any";
+    smallStep?: number;
+    largeStep?: number;
+    allowOutOfRange?: boolean;
+    allowWheelScrub?: boolean;
+    snapOnStep?: boolean;
+    format?: Intl.NumberFormatOptions;
+    locale?: Intl.LocalesArgument;
+    name?: string;
+    inputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "disabled" | "value">;
+    inputRef?: Ref<HTMLInputElement>;
+    size?: NumberFieldSize;
+    showSteppers?: boolean;
+}
+
+declare const NumberField: react.ForwardRefExoticComponent<NumberFieldProps & react.RefAttributes<HTMLDivElement>>;
+
+type OTPFieldSize = "sm" | "md" | "lg";
+type OTPFieldValidationType = "numeric" | "alpha" | "alphanumeric" | "none";
+interface OTPFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange"> {
+    autoComplete?: string;
+    autoSubmit?: boolean;
+    defaultValue?: string;
+    description?: ReactNode;
+    disabled?: boolean;
+    error?: ReactNode;
+    form?: string;
+    id?: string;
+    inputMode?: InputHTMLAttributes<HTMLInputElement>["inputMode"];
+    inputRef?: Ref<HTMLInputElement>;
+    invalid?: boolean;
+    label?: ReactNode;
+    length?: number;
+    mask?: boolean;
+    name?: string;
+    normalizeValue?: (value: string) => string;
+    onValueChange?: (value: string) => void;
+    onValueComplete?: (value: string) => void;
+    onValueInvalid?: (value: string) => void;
+    readOnly?: boolean;
+    required?: boolean;
+    separatorEvery?: number;
+    separatorLabel?: string;
+    size?: OTPFieldSize;
+    validationType?: OTPFieldValidationType;
+    value?: string;
+}
+
+declare const OTPField: react.ForwardRefExoticComponent<OTPFieldProps & react.RefAttributes<HTMLDivElement>>;
+
+type PaginationSize = "sm" | "md";
+type PaginationSiblingCount = 0 | 1 | 2;
+interface PaginationProps extends HTMLAttributes<HTMLElement> {
+    page: number;
+    totalPages: number;
+    onPageChange?: (page: number) => void;
+    siblingCount?: PaginationSiblingCount;
+    size?: PaginationSize;
+    disabled?: boolean;
+    getPageHref?: (page: number) => string;
+}
+
+declare const Pagination: react.ForwardRefExoticComponent<PaginationProps & react.RefAttributes<HTMLElement>>;
+
+type PopoverSide = "top" | "right" | "bottom" | "left";
+type PopoverAlign = "start" | "center" | "end";
+type PopoverSize = "sm" | "md";
+interface PopoverProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    trigger: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    side?: PopoverSide;
+    align?: PopoverAlign;
+    sideOffset?: number;
+    size?: PopoverSize;
+    modal?: boolean | "trap-focus";
+    openOnHover?: boolean;
+    delay?: number;
+    closeDelay?: number;
+    showArrow?: boolean;
+    showCloseButton?: boolean;
+    closeLabel?: string;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare const Popover: react.ForwardRefExoticComponent<PopoverProps & react.RefAttributes<HTMLDivElement>>;
+
+type ProgressIntent = "neutral" | "info" | "success" | "warning" | "danger";
+type ProgressSize = "sm" | "md" | "lg";
+interface ProgressProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    description?: ReactNode;
+    format?: Intl.NumberFormatOptions;
+    getAriaValueText?: (formattedValue: string, value: number | null) => string;
+    intent?: ProgressIntent;
+    label?: ReactNode;
+    locale?: Intl.LocalesArgument;
+    max?: number;
+    min?: number;
+    showValue?: boolean;
+    size?: ProgressSize;
+    value: number | null;
+    valueLabel?: ReactNode;
+}
+interface MeterProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    description?: ReactNode;
+    format?: Intl.NumberFormatOptions;
+    getAriaValueText?: (formattedValue: string, value: number) => string;
+    intent?: ProgressIntent;
+    label?: ReactNode;
+    locale?: Intl.LocalesArgument;
+    max?: number;
+    min?: number;
+    showValue?: boolean;
+    size?: ProgressSize;
+    value: number;
+    valueLabel?: ReactNode;
+}
+
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+declare const Meter: react.ForwardRefExoticComponent<MeterProps & react.RefAttributes<HTMLDivElement>>;
+
+type RadioGroupOrientation = "vertical" | "horizontal";
+interface RadioGroupOption {
+    value: string;
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+}
+interface RadioGroupProps {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    label?: ReactNode;
+    description?: ReactNode;
+    options: RadioGroupOption[];
+    orientation?: RadioGroupOrientation;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    className?: string;
+    onValueChange?: (value: string) => void;
+}
+
+declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type SelectSize = "sm" | "md" | "lg";
+interface SelectOption {
+    value: string;
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    textValue?: string;
+}
+interface SelectProps {
+    id?: string;
+    name?: string;
+    value?: string | null;
+    defaultValue?: string | null;
+    label?: ReactNode;
+    description?: ReactNode;
+    placeholder?: ReactNode;
+    options: SelectOption[];
+    selectSize?: SelectSize;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    className?: string;
+    triggerClassName?: string;
+    ariaLabel?: string;
+    onValueChange?: (value: string | null) => void;
+}
+
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+type ScrollAreaScrollbarVisibility = "auto" | "always" | "none";
+type ScrollAreaSize = "sm" | "md" | "lg";
+interface ScrollAreaProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    children?: ReactNode;
+    contentClassName?: string;
+    height?: CSSProperties["height"];
+    maxHeight?: CSSProperties["maxHeight"];
+    maxWidth?: CSSProperties["maxWidth"];
+    minHeight?: CSSProperties["minHeight"];
+    minWidth?: CSSProperties["minWidth"];
+    overflowEdgeThreshold?: number | Partial<{
+        xStart: number;
+        xEnd: number;
+        yStart: number;
+        yEnd: number;
+    }>;
+    scrollbarVisibility?: ScrollAreaScrollbarVisibility;
+    showEdgeShadows?: boolean;
+    size?: ScrollAreaSize;
+    viewportClassName?: string;
+    viewportRef?: Ref<HTMLDivElement>;
+    width?: CSSProperties["width"];
+}
+
+declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
+
+type SeparatorOrientation = "horizontal" | "vertical";
+type SeparatorSpacing = "none" | "xs" | "sm" | "md" | "lg";
+type SeparatorVariant = "subtle" | "strong";
+interface SeparatorProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: SeparatorOrientation;
+    spacing?: SeparatorSpacing;
+    variant?: SeparatorVariant;
+    decorative?: boolean;
+}
+
+declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+
+type SidePanelPosition = "left" | "right";
+type SidePanelSize = "sm" | "md" | "lg";
+type SidePanelVariant = "plain" | "bordered" | "elevated";
+interface SidePanelProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    title?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    position?: SidePanelPosition;
+    size?: SidePanelSize;
+    sticky?: boolean;
+    variant?: SidePanelVariant;
+    contentClassName?: string;
+    footerClassName?: string;
+    headerClassName?: string;
+}
+
+declare const SidePanel: react.ForwardRefExoticComponent<SidePanelProps & react.RefAttributes<HTMLElement>>;
+
+type SliderOrientation = "horizontal" | "vertical";
+type SliderSize = "sm" | "md";
+type SliderValue = number | number[];
+interface SliderProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    value?: SliderValue;
+    defaultValue?: SliderValue;
+    onValueChange?: (value: SliderValue) => void;
+    onValueCommitted?: (value: SliderValue) => void;
+    label?: string;
+    description?: string;
+    showValue?: boolean;
+    valueSuffix?: string;
+    thumbLabels?: string[];
+    disabled?: boolean;
+    invalid?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    largeStep?: number;
+    minStepsBetweenValues?: number;
+    name?: string;
+    orientation?: SliderOrientation;
+    size?: SliderSize;
+}
+
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLDivElement>>;
+
+type SkeletonShape = "text" | "rectangle" | "circle";
+interface SkeletonProps extends HTMLAttributes<HTMLSpanElement> {
+    shape?: SkeletonShape;
+    width?: number | string;
+    height?: number | string;
+    lines?: number;
+    animated?: boolean;
+}
+
+declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLSpanElement>>;
+
+type SpinnerSize = "sm" | "md" | "lg";
+type SpinnerIntent = "neutral" | "primary" | "success" | "warning" | "danger";
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    size?: SpinnerSize;
+    intent?: SpinnerIntent;
+    label?: string;
+}
+
+declare const Spinner: react.ForwardRefExoticComponent<SpinnerProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface SwitchProps {
+    id?: string;
+    name?: string;
+    value?: string;
+    uncheckedValue?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    label?: ReactNode;
+    description?: ReactNode;
+    className?: string;
+    onCheckedChange?: (checked: boolean) => void;
+}
+
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLElement>>;
+
+type TabsOrientation = "horizontal" | "vertical";
+type TabsVariant = "line" | "contained";
+interface TabsItem {
+    value: string;
+    label: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+interface TabsProps {
+    value?: string | null;
+    defaultValue?: string | null;
+    items: TabsItem[];
+    orientation?: TabsOrientation;
+    variant?: TabsVariant;
+    keepMounted?: boolean;
+    className?: string;
+    listClassName?: string;
+    panelClassName?: string;
+    ariaLabel?: string;
+    onValueChange?: (value: string | null) => void;
+}
+
+declare const Tabs: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<HTMLDivElement>>;
+
+type TableDensity = "compact" | "comfortable";
+type TableVariant = "plain" | "outlined";
+interface TableRootProps extends HTMLAttributes<HTMLDivElement> {
+    density?: TableDensity;
+    variant?: TableVariant;
+}
+type TableProps = TableHTMLAttributes<HTMLTableElement>;
+type TableSectionProps = HTMLAttributes<HTMLTableSectionElement>;
+type TableRowProps = HTMLAttributes<HTMLTableRowElement>;
+type TableHeaderCellProps = ThHTMLAttributes<HTMLTableCellElement>;
+type TableCellProps = TdHTMLAttributes<HTMLTableCellElement>;
+type TableCaptionProps = HTMLAttributes<HTMLTableCaptionElement>;
+
+declare const TableRoot: react.ForwardRefExoticComponent<TableRootProps & react.RefAttributes<HTMLDivElement>>;
+declare const Table: react.ForwardRefExoticComponent<TableProps & react.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: react.ForwardRefExoticComponent<TableSectionProps & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: react.ForwardRefExoticComponent<TableSectionProps & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: react.ForwardRefExoticComponent<TableSectionProps & react.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: react.ForwardRefExoticComponent<TableRowProps & react.RefAttributes<HTMLTableRowElement>>;
+declare const TableHeaderCell: react.ForwardRefExoticComponent<TableHeaderCellProps & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: react.ForwardRefExoticComponent<TableCellProps & react.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: react.ForwardRefExoticComponent<TableCaptionProps & react.RefAttributes<HTMLTableCaptionElement>>;
+
+type ToastPlacement = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+type ToastIntent = "info" | "success" | "warning" | "error" | (string & {});
+type ToastOptions<Data extends object = Record<string, never>> = ToastManagerAddOptions<Data>;
+type ToastUpdateOptions<Data extends object = Record<string, never>> = ToastManagerUpdateOptions<Data>;
+type ToastPromiseOptions<Value, Data extends object = Record<string, never>> = ToastManagerPromiseOptions<Value, Data>;
+type ToastItem<Data extends object = Record<string, never>> = ToastObject<Data>;
+type ToastManager<Data extends object = Record<string, never>> = UseToastManagerReturnValue<Data>;
+interface ToastProviderProps {
+    children?: ReactNode;
+    limit?: number;
+    timeout?: number;
+}
+interface ToastViewportProps {
+    placement?: ToastPlacement;
+    className?: string;
+    toastClassName?: string;
+    closeLabel?: string;
+    swipeDirection?: "up" | "down" | "left" | "right" | ("up" | "down" | "left" | "right")[];
+}
+
+declare function ToastProvider({ children, limit, timeout }: ToastProviderProps): react.JSX.Element;
+declare function ToastViewport({ className, closeLabel, placement, swipeDirection, toastClassName, }: ToastViewportProps): react.JSX.Element;
+declare function useToast(): _base_ui_react.UseToastManagerReturnValue<any>;
+declare const createToastManager: typeof Toast.createToastManager;
+
+type ToggleSize = "sm" | "md";
+type ToggleVariant = "plain" | "outlined";
+type ToggleGroupOrientation = "horizontal" | "vertical";
+interface ToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange" | "value"> {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    size?: ToggleSize;
+    variant?: ToggleVariant;
+    value?: string;
+}
+interface ToggleGroupItem {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface ToggleGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    items: ToggleGroupItem[];
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    multiple?: boolean;
+    disabled?: boolean;
+    loopFocus?: boolean;
+    orientation?: ToggleGroupOrientation;
+    size?: ToggleSize;
+    variant?: ToggleVariant;
+    ariaLabel?: string;
+}
+
+declare const Toggle: react.ForwardRefExoticComponent<ToggleProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ToggleGroup: react.ForwardRefExoticComponent<ToggleGroupProps & react.RefAttributes<HTMLDivElement>>;
+
+type ToolbarOrientation = "horizontal" | "vertical";
+type ToolbarSize = "sm" | "md";
+type ToolbarVariant = "plain" | "outlined";
+interface ToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    disabled?: boolean;
+    loopFocus?: boolean;
+    orientation?: ToolbarOrientation;
+    size?: ToolbarSize;
+    variant?: ToolbarVariant;
+    ariaLabel?: string;
+}
+interface ToolbarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    disabled?: boolean;
+}
+interface ToolbarButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    focusableWhenDisabled?: boolean;
+}
+interface ToolbarLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    children: ReactNode;
+}
+interface ToolbarInputProps extends InputHTMLAttributes<HTMLInputElement> {
+    focusableWhenDisabled?: boolean;
+}
+interface ToolbarSeparatorProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: ToolbarOrientation;
+}
+
+declare const Toolbar: react.ForwardRefExoticComponent<ToolbarProps & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarGroup: react.ForwardRefExoticComponent<ToolbarGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarButton: react.ForwardRefExoticComponent<ToolbarButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare const ToolbarLink: react.ForwardRefExoticComponent<ToolbarLinkProps & react.RefAttributes<HTMLAnchorElement>>;
+declare const ToolbarInput: react.ForwardRefExoticComponent<ToolbarInputProps & react.RefAttributes<HTMLInputElement>>;
+declare const ToolbarSeparator: react.ForwardRefExoticComponent<ToolbarSeparatorProps & react.RefAttributes<HTMLDivElement>>;
+
+type TooltipSide = "top" | "right" | "bottom" | "left";
+type TooltipAlign = "start" | "center" | "end";
+interface TooltipProviderProps {
+    children?: ReactNode;
+    delay?: number;
+    closeDelay?: number;
+    timeout?: number;
+}
+interface TooltipProps {
+    children: ReactNode;
+    content: ReactNode;
+    ariaLabel?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    side?: TooltipSide;
+    align?: TooltipAlign;
+    sideOffset?: number;
+    delay?: number;
+    closeDelay?: number;
+    closeOnClick?: boolean;
+    className?: string;
+    triggerClassName?: string;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare function TooltipProvider({ children, closeDelay, delay, timeout }: TooltipProviderProps): react.JSX.Element;
+declare function Tooltip({ align, ariaLabel, children, className, closeDelay, closeOnClick, content, defaultOpen, delay, disabled, onOpenChange, open, side, sideOffset, triggerClassName, }: TooltipProps): react.JSX.Element;
+
+declare const UI_PACKAGE_NAME = "@mithunsalinda/veyqor-ui";
+declare const UI_PACKAGE_VERSION = "0.1.0";
+
+export { Accordion, type AccordionItem, type AccordionProps, type AccordionSize, type AccordionVariant, Alert, type AlertIntent, type AlertProps, type AlertVariant, Avatar, type AvatarProps, type AvatarShape, type AvatarSize, Badge, type BadgeIntent, type BadgeProps, type BadgeShape, type BadgeSize, type BadgeVariant, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, type BreadcrumbSize, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardContent, CardDescription, type CardDescriptionProps, CardFooter, CardHeader, CardMedia, type CardMediaProps, type CardPadding, type CardProps, type CardSectionProps, CardTitle, type CardTitleProps, type CardVariant, Checkbox, type CheckboxProps, Collapsible, type CollapsibleProps, type CollapsibleSize, type CollapsibleVariant, Combobox, type ComboboxOption, type ComboboxProps, type ComboboxSize, Command, type CommandAction, CommandDialog, type CommandDialogProps, type CommandGroup, type CommandProps, type CommandSize, ContextMenu, type ContextMenuAlign, type ContextMenuItem, type ContextMenuProps, type ContextMenuSide, type ContextMenuSize, DatePicker, type DatePickerProps, type DatePickerSize, Dialog, type DialogProps, type DialogSize, Drawer, type DrawerProps, type DrawerSide, type DrawerSize, DropdownMenu, type DropdownMenuAlign, type DropdownMenuItem, type DropdownMenuProps, type DropdownMenuSide, type DropdownMenuSize, EmptyState, type EmptyStateAlign, type EmptyStateDensity, type EmptyStateProps, type EmptyStateTone, Fieldset, type FieldsetDensity, type FieldsetProps, type FieldsetVariant, FormField, type FormFieldControlProps, type FormFieldProps, Input, type InputProps, type InputSize, Menubar, type MenubarAlign, type MenubarMenu, type MenubarMenuItem, type MenubarOrientation, type MenubarProps, type MenubarSize, Meter, type MeterProps, NavigationMenu, type NavigationMenuAlign, type NavigationMenuFeaturedItem, type NavigationMenuItem, type NavigationMenuLinkItem, type NavigationMenuOrientation, type NavigationMenuProps, type NavigationMenuSide, type NavigationMenuSize, NumberField, type NumberFieldProps, type NumberFieldSize, OTPField, type OTPFieldProps, type OTPFieldSize, type OTPFieldValidationType, Pagination, type PaginationProps, type PaginationSiblingCount, type PaginationSize, Popover, type PopoverAlign, type PopoverProps, type PopoverSide, type PopoverSize, Progress, type ProgressIntent, type ProgressProps, type ProgressSize, RadioGroup, type RadioGroupOption, type RadioGroupOrientation, type RadioGroupProps, ScrollArea, type ScrollAreaProps, type ScrollAreaScrollbarVisibility, type ScrollAreaSize, Select, type SelectOption, type SelectProps, type SelectSize, Separator, type SeparatorOrientation, type SeparatorProps, type SeparatorSpacing, type SeparatorVariant, SidePanel, type SidePanelPosition, type SidePanelProps, type SidePanelSize, type SidePanelVariant, Skeleton, type SkeletonProps, type SkeletonShape, Slider, type SliderOrientation, type SliderProps, type SliderSize, type SliderValue, Spinner, type SpinnerIntent, type SpinnerProps, type SpinnerSize, Switch, type SwitchProps, Table, TableBody, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, type TableDensity, TableFooter, TableHeader, TableHeaderCell, type TableHeaderCellProps, type TableProps, TableRoot, type TableRootProps, TableRow, type TableRowProps, type TableSectionProps, type TableVariant, Tabs, type TabsItem, type TabsOrientation, type TabsProps, type TabsVariant, type ToastIntent, type ToastItem, type ToastManager, type ToastOptions, type ToastPlacement, type ToastPromiseOptions, ToastProvider, type ToastProviderProps, type ToastUpdateOptions, ToastViewport, type ToastViewportProps, Toggle, ToggleGroup, type ToggleGroupItem, type ToggleGroupOrientation, type ToggleGroupProps, type ToggleProps, type ToggleSize, type ToggleVariant, Toolbar, ToolbarButton, type ToolbarButtonProps, ToolbarGroup, type ToolbarGroupProps, ToolbarInput, type ToolbarInputProps, ToolbarLink, type ToolbarLinkProps, type ToolbarOrientation, type ToolbarProps, ToolbarSeparator, type ToolbarSeparatorProps, type ToolbarSize, type ToolbarVariant, Tooltip, type TooltipAlign, type TooltipProps, TooltipProvider, type TooltipProviderProps, type TooltipSide, UI_PACKAGE_NAME, UI_PACKAGE_VERSION, createToastManager, useToast };