brd-ui-kit 0.1.75 → 0.1.76

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

@@ -1,58 +1,58 @@
+import { ComponentPropsWithoutRef, ComponentRef, ReactNode, Ref } from 'react';
 import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
 import { IconName } from 'phosphor-strokes-icons/by-name';
-import * as React from "react";
-type DropdownMenuRef = React.ComponentRef<typeof DropdownMenuPrimitive.Root>;
-type DropdownMenuProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Root> & {
-    ref?: React.Ref<DropdownMenuRef>;
-};
-type DropdownMenuTriggerRef = React.ComponentRef<typeof DropdownMenuPrimitive.Trigger>;
-type DropdownMenuTriggerProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Trigger> & {
-    ref?: React.Ref<DropdownMenuTriggerRef>;
-};
-type DropdownMenuContentRef = React.ComponentRef<typeof DropdownMenuPrimitive.Content>;
-type DropdownMenuContentProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> & {
-    ref?: React.Ref<DropdownMenuContentRef>;
-};
-type DropdownMenuItemRef = React.ComponentRef<typeof DropdownMenuPrimitive.Item>;
-type DropdownMenuItemProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
-    ref?: React.Ref<DropdownMenuItemRef>;
-};
-type DropdownMenuCheckboxItemRef = React.ComponentRef<typeof DropdownMenuPrimitive.CheckboxItem>;
-type DropdownMenuCheckboxItemProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem> & {
-    ref?: React.Ref<DropdownMenuCheckboxItemRef>;
-    itemIndicator?: React.ReactNode;
+type DropdownMenuRef = ComponentRef<typeof DropdownMenuPrimitive.Root>;
+type DropdownMenuProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Root> & {
+    ref?: Ref<DropdownMenuRef>;
+};
+type DropdownMenuTriggerRef = ComponentRef<typeof DropdownMenuPrimitive.Trigger>;
+type DropdownMenuTriggerProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Trigger> & {
+    ref?: Ref<DropdownMenuTriggerRef>;
+};
+type DropdownMenuContentRef = ComponentRef<typeof DropdownMenuPrimitive.Content>;
+type DropdownMenuContentProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> & {
+    ref?: Ref<DropdownMenuContentRef>;
+};
+type DropdownMenuItemRef = ComponentRef<typeof DropdownMenuPrimitive.Item>;
+type DropdownMenuItemProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
+    ref?: Ref<DropdownMenuItemRef>;
+};
+type DropdownMenuCheckboxItemRef = ComponentRef<typeof DropdownMenuPrimitive.CheckboxItem>;
+type DropdownMenuCheckboxItemProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem> & {
+    ref?: Ref<DropdownMenuCheckboxItemRef>;
+    itemIndicator?: ReactNode;
     closeOnSelect?: boolean;
 };
-type DropdownMenuLabelRef = React.ComponentRef<typeof DropdownMenuPrimitive.Label>;
-type DropdownMenuLabelProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
-    ref?: React.Ref<DropdownMenuLabelRef>;
+type DropdownMenuLabelRef = ComponentRef<typeof DropdownMenuPrimitive.Label>;
+type DropdownMenuLabelProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
+    ref?: Ref<DropdownMenuLabelRef>;
 };
-type DropdownMenuSeparatorRef = React.ComponentRef<typeof DropdownMenuPrimitive.Separator>;
-type DropdownMenuSeparatorProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator> & {
-    ref?: React.Ref<DropdownMenuSeparatorRef>;
+type DropdownMenuSeparatorRef = ComponentRef<typeof DropdownMenuPrimitive.Separator>;
+type DropdownMenuSeparatorProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator> & {
+    ref?: Ref<DropdownMenuSeparatorRef>;
 };
-type DropdownMenuSubTriggerRef = React.ComponentRef<typeof DropdownMenuPrimitive.SubTrigger>;
-type DropdownMenuSubTriggerProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
-    ref?: React.Ref<DropdownMenuSubTriggerRef>;
+type DropdownMenuSubTriggerRef = ComponentRef<typeof DropdownMenuPrimitive.SubTrigger>;
+type DropdownMenuSubTriggerProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
+    ref?: Ref<DropdownMenuSubTriggerRef>;
 };
-type DropdownMenuSubContentRef = React.ComponentRef<typeof DropdownMenuPrimitive.SubContent>;
-type DropdownMenuSubContentProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent> & {
-    ref?: React.Ref<DropdownMenuSubContentRef>;
+type DropdownMenuSubContentRef = ComponentRef<typeof DropdownMenuPrimitive.SubContent>;
+type DropdownMenuSubContentProps = ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent> & {
+    ref?: Ref<DropdownMenuSubContentRef>;
 };
 type DropdownMenuCheckboxOption = {
     key: string;
-    label: React.ReactNode;
+    label: ReactNode;
     checked: boolean;
     disabled?: boolean;
     className?: string;
     checkedClassName?: string;
     textValue?: string;
-    itemIndicator?: React.ReactNode;
-    endAdornment?: React.ReactNode;
-    checkedEndAdornment?: React.ReactNode;
+    itemIndicator?: ReactNode;
+    endAdornment?: ReactNode;
+    checkedEndAdornment?: ReactNode;
 };
 type CheckboxDropdownMenuProps = {
-    trigger: React.ReactNode;
+    trigger: ReactNode;
     items: DropdownMenuCheckboxOption[];
     onItemCheckedChange: (key: string, checked: boolean) => void;
     contentProps?: Omit<DropdownMenuContentProps, "children">;
@@ -83,7 +83,7 @@ type DropdownMenuConfigSeparator = DropdownMenuConfigBase & {
 type DropdownMenuConfigItem = DropdownMenuConfigBase & {
     type?: "item";
     label: string;
-    icon?: React.ReactNode;
+    icon?: ReactNode;
     iconType?: IconName;
     shortcut?: string;
     alert?: boolean;
@@ -92,7 +92,7 @@ type DropdownMenuConfigItem = DropdownMenuConfigBase & {
 };
 type DropdownMenuConfigNode = DropdownMenuConfigLabel | DropdownMenuConfigSeparator | DropdownMenuConfigItem;
 type ConfigurableDropdownMenuProps = {
-    trigger: React.ReactNode;
+    trigger: ReactNode;
     items: DropdownMenuConfigNode[];
     onAction?: (item: DropdownMenuConfigItem) => void;
     contentProps?: Omit<DropdownMenuContentProps, "children">;

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

@@ -1,8 +1,8 @@
 import { StrokeIconProps } from 'phosphor-strokes-icons';
-import { IconName } from 'phosphor-strokes-icons/by-name';
+import { DynamicIconName } from 'phosphor-strokes-icons/dynamic';
 import { IconPreset } from './icon-presets';
 type Props = React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> & {
-    type: IconName;
+    type: DynamicIconName;
     size?: IconPreset | StrokeIconProps["size"];
     strokeWidth?: StrokeIconProps["strokeWidth"];
     color?: StrokeIconProps["color"];
@@ -15,5 +15,5 @@ type Props = React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLD
     svgProps?: Omit<React.SVGProps<SVGSVGElement>, "size" | "strokeWidth" | "color" | "className">;
 };
 export declare const Icon: ({ type, size, strokeWidth, color, absoluteStrokeWidth, classes, className, svgProps, disabled, ...rest }: Props) => import("react/jsx-runtime").JSX.Element;
-export type IconType = IconName;
+export type IconType = DynamicIconName;
 export type { Props as IconProps };

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

@@ -1,7 +1,7 @@
+import { ComponentPropsWithRef } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { inputVariants } from './input.styles';
-import * as React from "react";
-type InputProps = React.ComponentPropsWithRef<"input"> & VariantProps<typeof inputVariants> & {
+type InputProps = ComponentPropsWithRef<"input"> & VariantProps<typeof inputVariants> & {
     className?: string;
 };
 declare const Input: ({ className, sizeInput, type, variant, ...props }: InputProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,11 +1,11 @@
 import { VariantProps } from 'class-variance-authority';
+import { ComponentProps } from 'react';
 import { Button } from '../button';
 import { inputGroupAddonVariants, inputGroupButtonVariants } from './input-group.styles';
-import * as React from "react";
-declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): import("react/jsx-runtime").JSX.Element;
-declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>): import("react/jsx-runtime").JSX.Element;
-declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
-declare function InputGroupInput(props: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
-declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroup({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupAddon({ className, align, ...props }: ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupText({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupInput(props: ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
 export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea, };

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

@@ -1,11 +1,11 @@
+import { ComponentPropsWithoutRef, ComponentRef, Ref } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { ClassProp } from 'class-variance-authority/types';
-import * as React from "react";
 import * as LabelPrimitive from "@radix-ui/react-label";
 declare const labelVariants: (props?: ClassProp | undefined) => string;
-type LabelRef = React.ComponentRef<typeof LabelPrimitive.Root>;
-type LabelProps = React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> & VariantProps<typeof labelVariants> & {
-    ref?: React.Ref<LabelRef>;
+type LabelRef = ComponentRef<typeof LabelPrimitive.Root>;
+type LabelProps = ComponentPropsWithoutRef<typeof LabelPrimitive.Root> & VariantProps<typeof labelVariants> & {
+    ref?: Ref<LabelRef>;
 };
 declare const Label: {
     ({ className, ref, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,10 +1,10 @@
-import * as React from "react";
+import { ComponentProps, ComponentPropsWithRef } from 'react';
 declare const Pagination: {
-    ({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...props }: ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
-type PaginationContentProps = React.ComponentPropsWithRef<"ul">;
-type PaginationItemProps = React.ComponentPropsWithRef<"li">;
+type PaginationContentProps = ComponentPropsWithRef<"ul">;
+type PaginationItemProps = ComponentPropsWithRef<"li">;
 declare const PaginationContent: {
     ({ className, ref, ...props }: PaginationContentProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
@@ -17,21 +17,21 @@ type PaginationLinkProps = {
     isActive?: boolean;
     variant?: "page" | "arrow-left" | "arrow-right";
     disabled?: boolean;
-} & React.ComponentProps<"a">;
+} & ComponentProps<"a">;
 declare const PaginationLink: {
     ({ className, isActive, variant, disabled, children, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const PaginationPrevious: {
-    ({ className, disabled, children, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    ({ className, disabled, children, ...props }: ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const PaginationNext: {
-    ({ className, disabled, children, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    ({ className, disabled, children, ...props }: ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const PaginationEllipsis: {
-    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 export { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, };

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

@@ -1,10 +1,10 @@
+import { ComponentProps } from 'react';
 import { Popover as PopoverPrimitive } from 'radix-ui';
-import * as React from "react";
-declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
-declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
-declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
-declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
-declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">): import("react/jsx-runtime").JSX.Element;
-declare function PopoverDescription({ className, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+declare function Popover({ ...props }: ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTrigger({ ...props }: ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverAnchor({ ...props }: ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverHeader({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTitle({ className, ...props }: ComponentProps<"h2">): import("react/jsx-runtime").JSX.Element;
+declare function PopoverDescription({ className, ...props }: ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
 export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

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

@@ -1,8 +1,8 @@
+import { ComponentPropsWithoutRef, ComponentRef, Ref } from 'react';
 import * as ProgressPrimitive from "@radix-ui/react-progress";
-import * as React from "react";
-type ProgressRef = React.ComponentRef<typeof ProgressPrimitive.Root>;
-type ProgressProps = React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> & {
-    ref?: React.Ref<ProgressRef>;
+type ProgressRef = ComponentRef<typeof ProgressPrimitive.Root>;
+type ProgressProps = ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> & {
+    ref?: Ref<ProgressRef>;
 };
 declare const Progress: {
     ({ className, value, max, ref, ...props }: ProgressProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,12 +1,12 @@
+import { ComponentPropsWithoutRef, ComponentRef, Ref } from 'react';
 import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
-import * as React from "react";
-type RadioGroupRef = React.ComponentRef<typeof RadioGroupPrimitive.Root>;
-type RadioGroupProps = React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
-    ref?: React.Ref<RadioGroupRef>;
+type RadioGroupRef = ComponentRef<typeof RadioGroupPrimitive.Root>;
+type RadioGroupProps = ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
+    ref?: Ref<RadioGroupRef>;
 };
-type RadioGroupItemRef = React.ComponentRef<typeof RadioGroupPrimitive.Item>;
-type RadioGroupItemProps = React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> & {
-    ref?: React.Ref<RadioGroupItemRef>;
+type RadioGroupItemRef = ComponentRef<typeof RadioGroupPrimitive.Item>;
+type RadioGroupItemProps = ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> & {
+    ref?: Ref<RadioGroupItemRef>;
 };
 declare const RadioGroup: {
     ({ className, ref, ...props }: RadioGroupProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,17 +1,17 @@
+import { ComponentProps } from 'react';
 import { Select as SelectPrimitive } from 'radix-ui';
-import * as React from "react";
-type SelectProps = React.ComponentProps<typeof SelectPrimitive.Root>;
-type SelectGroupProps = React.ComponentProps<typeof SelectPrimitive.Group>;
-type SelectValueProps = React.ComponentProps<typeof SelectPrimitive.Value>;
-type SelectTriggerProps = React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+type SelectProps = ComponentProps<typeof SelectPrimitive.Root>;
+type SelectGroupProps = ComponentProps<typeof SelectPrimitive.Group>;
+type SelectValueProps = ComponentProps<typeof SelectPrimitive.Value>;
+type SelectTriggerProps = ComponentProps<typeof SelectPrimitive.Trigger> & {
     size?: "sm" | "default";
 };
-type SelectContentProps = React.ComponentProps<typeof SelectPrimitive.Content>;
-type SelectLabelProps = React.ComponentProps<typeof SelectPrimitive.Label>;
-type SelectItemProps = React.ComponentProps<typeof SelectPrimitive.Item>;
-type SelectSeparatorProps = React.ComponentProps<typeof SelectPrimitive.Separator>;
-type SelectScrollUpButtonProps = React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>;
-type SelectScrollDownButtonProps = React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>;
+type SelectContentProps = ComponentProps<typeof SelectPrimitive.Content>;
+type SelectLabelProps = ComponentProps<typeof SelectPrimitive.Label>;
+type SelectItemProps = ComponentProps<typeof SelectPrimitive.Item>;
+type SelectSeparatorProps = ComponentProps<typeof SelectPrimitive.Separator>;
+type SelectScrollUpButtonProps = ComponentProps<typeof SelectPrimitive.ScrollUpButton>;
+type SelectScrollDownButtonProps = ComponentProps<typeof SelectPrimitive.ScrollDownButton>;
 declare function Select({ ...props }: SelectProps): import("react/jsx-runtime").JSX.Element;
 declare function SelectGroup({ className, ...props }: SelectGroupProps): import("react/jsx-runtime").JSX.Element;
 declare function SelectValue({ ...props }: SelectValueProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/select-calendar-menu/select-calendar-menu.d.ts

@@ -1,19 +1,19 @@
+import { ComponentProps } from 'react';
 import { DateRange } from 'react-day-picker';
 import { Calendar } from '../calendar';
 import { Icon } from '../icon';
 import { PopoverContent } from '../popover';
-import * as React from "react";
 type SelectCalendarMenuBaseProps = {
     placeholder?: string;
     size?: "sm" | "default";
     disabled?: boolean;
     className?: string;
     iconPosition?: "left" | "right";
-    iconType?: React.ComponentProps<typeof Icon>["type"];
+    iconType?: ComponentProps<typeof Icon>["type"];
     closeOnSelect?: boolean;
     collisionPadding?: number;
-    calendarProps?: Omit<React.ComponentProps<typeof Calendar>, "mode" | "selected" | "onSelect" | "appendFooter">;
-    popoverContentProps?: Omit<React.ComponentProps<typeof PopoverContent>, "children">;
+    calendarProps?: Omit<ComponentProps<typeof Calendar>, "mode" | "selected" | "onSelect" | "appendFooter">;
+    popoverContentProps?: Omit<ComponentProps<typeof PopoverContent>, "children">;
 };
 type SelectCalendarMenuSingleProps = SelectCalendarMenuBaseProps & {
     mode?: "single";

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

@@ -1,8 +1,8 @@
+import { ComponentPropsWithoutRef, ComponentRef, Ref } from 'react';
 import * as SeparatorPrimitive from "@radix-ui/react-separator";
-import * as React from "react";
-type SeparatorRef = React.ComponentRef<typeof SeparatorPrimitive.Root>;
-type SeparatorProps = React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> & {
-    ref?: React.Ref<SeparatorRef>;
+type SeparatorRef = ComponentRef<typeof SeparatorPrimitive.Root>;
+type SeparatorProps = ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> & {
+    ref?: Ref<SeparatorRef>;
 };
 declare const Separator: {
     ({ className, orientation, decorative, ref, ...props }: SeparatorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,8 +1,8 @@
+import { ComponentPropsWithoutRef, ComponentRef, Ref } from 'react';
 import * as SwitchPrimitives from "@radix-ui/react-switch";
-import * as React from "react";
-type SwitchRef = React.ComponentRef<typeof SwitchPrimitives.Root>;
-type SwitchProps = React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> & {
-    ref?: React.Ref<SwitchRef>;
+type SwitchRef = ComponentRef<typeof SwitchPrimitives.Root>;
+type SwitchProps = ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> & {
+    ref?: Ref<SwitchRef>;
 };
 declare const Switch: {
     ({ className, ref, ...props }: SwitchProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,50 +1,50 @@
-import * as React from "react";
+import { HTMLAttributes, RefObject, TdHTMLAttributes, ThHTMLAttributes } from 'react';
 declare const Table: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLTableElement> & {
-        ref?: React.RefObject<HTMLTableElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLTableElement> & {
+        ref?: RefObject<HTMLTableElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableHeader: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLTableSectionElement> & {
-        ref?: React.RefObject<HTMLTableSectionElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLTableSectionElement> & {
+        ref?: RefObject<HTMLTableSectionElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableBody: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLTableSectionElement> & {
-        ref?: React.RefObject<HTMLTableSectionElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLTableSectionElement> & {
+        ref?: RefObject<HTMLTableSectionElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableFooter: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLTableSectionElement> & {
-        ref?: React.RefObject<HTMLTableSectionElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLTableSectionElement> & {
+        ref?: RefObject<HTMLTableSectionElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableRow: {
-    ({ ref, className, clickable, onClick, ...props }: React.HTMLAttributes<HTMLTableRowElement> & {
-        ref?: React.RefObject<HTMLTableRowElement | null>;
+    ({ ref, className, clickable, onClick, ...props }: HTMLAttributes<HTMLTableRowElement> & {
+        ref?: RefObject<HTMLTableRowElement | null>;
         clickable?: boolean;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableHead: {
-    ({ ref, className, ...props }: React.ThHTMLAttributes<HTMLTableCellElement> & {
-        ref?: React.RefObject<HTMLTableCellElement | null>;
+    ({ ref, className, ...props }: ThHTMLAttributes<HTMLTableCellElement> & {
+        ref?: RefObject<HTMLTableCellElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableCell: {
-    ({ ref, className, ...props }: React.TdHTMLAttributes<HTMLTableCellElement> & {
-        ref?: React.RefObject<HTMLTableCellElement | null>;
+    ({ ref, className, ...props }: TdHTMLAttributes<HTMLTableCellElement> & {
+        ref?: RefObject<HTMLTableCellElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const TableCaption: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLTableCaptionElement> & {
-        ref?: React.RefObject<HTMLTableCaptionElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLTableCaptionElement> & {
+        ref?: RefObject<HTMLTableCaptionElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

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

@@ -1,25 +1,25 @@
 import { VariantProps } from 'class-variance-authority';
+import { ComponentPropsWithoutRef, ComponentRef, RefObject, ForwardRefExoticComponent, RefAttributes } from 'react';
 import { tabsListVariants, tabsTriggerVariants } from './tabs.styles';
 import * as TabsPrimitive from "@radix-ui/react-tabs";
-import * as React from "react";
-declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
-type TabsListProps = React.ComponentPropsWithoutRef<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>;
+declare const Tabs: ForwardRefExoticComponent<TabsPrimitive.TabsProps & RefAttributes<HTMLDivElement>>;
+type TabsListProps = ComponentPropsWithoutRef<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>;
 declare const TabsList: {
     ({ ref, className, variant, ...props }: TabsListProps & {
-        ref?: React.RefObject<React.ComponentRef<typeof TabsPrimitive.List> | null>;
+        ref?: RefObject<ComponentRef<typeof TabsPrimitive.List> | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string | undefined;
 };
-type TabsTriggerProps = React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger> & VariantProps<typeof tabsTriggerVariants>;
+type TabsTriggerProps = ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger> & VariantProps<typeof tabsTriggerVariants>;
 declare const TabsTrigger: {
     ({ ref, className, variant: variantProp, ...props }: TabsTriggerProps & {
-        ref?: React.RefObject<React.ComponentRef<typeof TabsPrimitive.Trigger> | null>;
+        ref?: RefObject<ComponentRef<typeof TabsPrimitive.Trigger> | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string | undefined;
 };
 declare const TabsContent: {
-    ({ ref, className, ...props }: React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content> & {
-        ref?: React.RefObject<React.ComponentRef<typeof TabsPrimitive.Content> | null>;
+    ({ ref, className, ...props }: ComponentPropsWithoutRef<typeof TabsPrimitive.Content> & {
+        ref?: RefObject<ComponentRef<typeof TabsPrimitive.Content> | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string | undefined;
 };

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

@@ -1,12 +1,12 @@
+import { ComponentPropsWithoutRef, ComponentRef, Ref, FC, ForwardRefExoticComponent, RefAttributes } from 'react';
 import * as TooltipPrimitive from "@radix-ui/react-tooltip";
-import * as React from "react";
-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 TooltipArrow: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
-type TooltipContentRef = React.ComponentRef<typeof TooltipPrimitive.Content>;
-type TooltipContentProps = React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> & {
-    ref?: React.Ref<TooltipContentRef>;
+declare const TooltipProvider: FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & RefAttributes<HTMLButtonElement>>;
+declare const TooltipArrow: ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & RefAttributes<SVGSVGElement>>;
+type TooltipContentRef = ComponentRef<typeof TooltipPrimitive.Content>;
+type TooltipContentProps = ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> & {
+    ref?: Ref<TooltipContentRef>;
 };
 declare const TooltipContent: {
     ({ className, sideOffset, ref, ...props }: TooltipContentProps): import("react/jsx-runtime").JSX.Element;