brd-ui-kit 0.1.75 → 0.1.76

package/dist/components/basic-chart/basic-chart.d.ts

@@ -6,7 +6,7 @@ type Props = {
     chartContainer?: React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
         config: ChartConfig;
     };
-    barChart?: CartesianChartProps<any> & {
+    barChart?: CartesianChartProps<Record<string, unknown>> & {
         ref?: React.Ref<SVGSVGElement> | undefined;
     };
     cartesianGrid?: React.ComponentProps<typeof CartesianGrid>;

package/dist/components/basic-table/basic-table.d.ts

@@ -1,12 +1,12 @@
 import { ColumnDef, ColumnFiltersState, PaginationState, Row, RowSelectionState, SortingState, Table as TanStackTable, Updater, VisibilityState } from '@tanstack/react-table';
-import * as React from "react";
+import { CSSProperties, ReactNode } from 'react';
 export type DataTableColumnMeta<TData = unknown> = {
     className?: string;
     headClassName?: string;
     cellClassName?: string;
-    style?: React.CSSProperties;
-    headStyle?: React.CSSProperties;
-    cellStyle?: React.CSSProperties;
+    style?: CSSProperties;
+    headStyle?: CSSProperties;
+    cellStyle?: CSSProperties;
     editable?: boolean;
     editKey?: Extract<keyof TData, string>;
     editComponent?: "input" | "textarea";
@@ -17,7 +17,7 @@ export type DataTableColumnMeta<TData = unknown> = {
 export interface DataTableProps<TData, TValue> {
     columns: ColumnDef<TData, TValue>[];
     data: TData[];
-    emptyState?: React.ReactNode;
+    emptyState?: ReactNode;
     sorting?: SortingState;
     columnFilters?: ColumnFiltersState;
     columnVisibility?: VisibilityState;

package/dist/components/data-table/data-table-actions-column.d.ts

@@ -1,17 +1,17 @@
 import { ColumnDef, Row } from '@tanstack/react-table';
+import { ReactNode } from 'react';
 import { DropdownMenuConfigNode } from '../ui/dropdown-menu';
-import * as React from "react";
 type DataTableActionsColumnOptions<TData> = {
     id?: string;
     header?: ColumnDef<TData>["header"];
     renderCell?: (ctx: {
         row: Row<TData>;
         data: TData;
-    }) => React.ReactNode;
+    }) => ReactNode;
     trigger?: (ctx: {
         row: Row<TData>;
         data: TData;
-    }) => React.ReactNode;
+    }) => ReactNode;
     menuItems?: DropdownMenuConfigNode[] | ((ctx: {
         row: Row<TData>;
         data: TData;

package/dist/components/data-table/data-table-bulk-actions.d.ts

@@ -1,6 +1,6 @@
 import { Row, Table } from '@tanstack/react-table';
+import { ReactNode } from 'react';
 import { DropdownMenuConfigNode } from '../ui/dropdown-menu';
-import * as React from "react";
 type DataTableBulkActionsContext<TData> = {
     table: Table<TData>;
     selectedRows: Row<TData>[];
@@ -10,8 +10,8 @@ type DataTableBulkActionsContext<TData> = {
 };
 type DataTableBulkActionsProps<TData> = {
     table: Table<TData>;
-    children?: (ctx: DataTableBulkActionsContext<TData>) => React.ReactNode;
-    trigger?: React.ReactNode | ((ctx: DataTableBulkActionsContext<TData>) => React.ReactNode);
+    children?: (ctx: DataTableBulkActionsContext<TData>) => ReactNode;
+    trigger?: ReactNode | ((ctx: DataTableBulkActionsContext<TData>) => ReactNode);
     menuItems?: DropdownMenuConfigNode[] | ((ctx: DataTableBulkActionsContext<TData>) => DropdownMenuConfigNode[]);
     onDeleteSelected?: (ctx: DataTableBulkActionsContext<TData>) => void;
 };

package/dist/components/data-table/data-table-column-visibility.d.ts

@@ -1,11 +1,11 @@
 import { Table, Updater, VisibilityState } from '@tanstack/react-table';
-import * as React from "react";
+import { ReactNode } from 'react';
 type DataTableColumnVisibilityProps<TData> = {
     table: Table<TData>;
     columnVisibility?: VisibilityState;
     onColumnVisibilityChange?: (updater: Updater<VisibilityState>) => void;
     triggerLabel?: string;
-    trigger?: React.ReactNode;
+    trigger?: ReactNode;
     menuLabel?: string;
     includeColumnIds?: string[];
     excludeColumnIds?: string[];

package/dist/components/data-table/data-table-filter.d.ts

@@ -1,11 +1,11 @@
 import { Table } from '@tanstack/react-table';
+import { ComponentProps } from 'react';
 import { Input } from '../ui/input';
-import * as React from "react";
 type DataTableFilterProps<TData> = {
     table: Table<TData>;
     searchableColumnIds?: string[];
     placeholder?: string;
-    inputProps?: Omit<React.ComponentProps<typeof Input>, "value" | "onChange">;
+    inputProps?: Omit<ComponentProps<typeof Input>, "value" | "onChange">;
 };
 declare function DataTableFilter<TData>({ table, searchableColumnIds, placeholder, inputProps, }: DataTableFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
 export { DataTableFilter };

package/dist/components/data-table/data-table-row-actions-column.d.ts

@@ -1,6 +1,6 @@
 import { ColumnDef, Row } from '@tanstack/react-table';
 import { IconName } from 'phosphor-strokes-icons/by-name';
-import * as React from "react";
+import { ReactNode } from 'react';
 type DataTableRowActionContext<TData> = {
     row: Row<TData>;
     data: TData;
@@ -19,7 +19,7 @@ type DataTableRowActionSeparator = DataTableRowActionBase & {
 type DataTableRowActionItem<TData> = DataTableRowActionBase & {
     type?: "item";
     label: string;
-    icon?: React.ReactNode;
+    icon?: ReactNode;
     iconType?: IconName;
     shortcut?: string;
     disabled?: boolean;
@@ -34,7 +34,7 @@ type DataTableRowActionsColumnOptions<TData> = {
     header?: ColumnDef<TData>["header"];
     align?: "start" | "center" | "end";
     editingRowId?: string | null;
-    trigger?: (ctx: DataTableRowActionContext<TData>) => React.ReactNode;
+    trigger?: (ctx: DataTableRowActionContext<TData>) => ReactNode;
     actions?: DataTableRowActionNode<TData>[] | ((ctx: DataTableRowActionContext<TData>) => DataTableRowActionNode<TData>[]);
     onStartEdit?: (ctx: DataTableRowActionContext<TData>) => void;
     onSaveEdit?: (ctx: DataTableRowActionContext<TData>) => void;

package/dist/components/data-table/use-data-table-editable-rows.d.ts

@@ -1,4 +1,4 @@
-import * as React from "react";
+import { Dispatch, SetStateAction } from 'react';
 type EditableRowKey<TData> = Extract<keyof TData, string>;
 type EditableValues = Record<string, string>;
 type DataTableRowEditStartEvent<TData> = {
@@ -34,11 +34,11 @@ type DataTableRowsChangeEvent<TData> = ({
 type UseDataTableEditableRowsOptions<TData> = {
     rows: TData[];
     getRowId: (row: TData) => string;
-    setRows?: React.Dispatch<React.SetStateAction<TData[]>>;
+    setRows?: Dispatch<SetStateAction<TData[]>>;
     editingRowId?: string | null;
     onEditingRowIdChange?: (rowId: string | null) => void;
     editingValues?: EditableValues;
-    onEditingValuesChange?: React.Dispatch<React.SetStateAction<EditableValues>>;
+    onEditingValuesChange?: Dispatch<SetStateAction<EditableValues>>;
     onRowDelete?: (event: DataTableRowDeleteEvent<TData>) => void;
     onRowEditCancel?: (event: DataTableRowEditCancelEvent<TData>) => void;
     onRowEditSave?: (event: DataTableRowEditSaveEvent<TData>) => void;
@@ -52,8 +52,8 @@ declare function useDataTableEditableRows<TData>({ rows, getRowId, setRows, edit
     editingRowId: string | null;
     editingValues: EditableValues;
     saveEditingRow: (rowId: string) => void;
-    setEditingValues: (updater: React.SetStateAction<EditableValues>) => void;
-    setEditingRowId: (updater: React.SetStateAction<string | null>) => void;
+    setEditingValues: (updater: SetStateAction<EditableValues>) => void;
+    setEditingRowId: (updater: SetStateAction<string | null>) => void;
     startEditingRow: (row: TData, editableKeys: readonly EditableRowKey<TData>[], overrides?: Partial<Record<EditableRowKey<TData>, string>>) => void;
 };
 export { useDataTableEditableRows };

package/dist/components/input-field/input-field.d.ts

@@ -1,8 +1,8 @@
-import { default as React } from 'react';
+import { ComponentPropsWithRef, ReactNode } from 'react';
 export type DateAddon = {
     id: string | number;
     position?: "inline-start" | "inline-end" | "block-start" | "block-end" | null;
-    component: React.ReactNode;
+    component: ReactNode;
 };
 type BaseProps = {
     date?: DateAddon[];
@@ -15,7 +15,7 @@ type BaseProps = {
         field?: string;
     };
 };
-type InputFieldProps = BaseProps & React.ComponentPropsWithRef<"input">;
+type InputFieldProps = BaseProps & ComponentPropsWithRef<"input">;
 export declare const InputField: ({ date, isValid, disabled, label, description, classes, ref, ...rest }: InputFieldProps) => import("react/jsx-runtime").JSX.Element;
 type InputProps = InputFieldProps;
 export type { InputFieldProps, InputProps };

package/dist/components/input-phone/input-phone.d.ts

@@ -1,8 +1,8 @@
-import { default as React } from 'react';
-type InputPhoneProps = Omit<React.ComponentProps<typeof MaskedInputField>, "inputRef">;
-declare const MaskedInputField: React.ForwardRefExoticComponent<Omit<{
+import { ComponentProps, ForwardRefExoticComponent, RefAttributes, ComponentType } from 'react';
+type InputPhoneProps = Omit<ComponentProps<typeof MaskedInputField>, "inputRef">;
+declare const MaskedInputField: ForwardRefExoticComponent<Omit<{
     [x: string]: unknown;
-}, "ref"> & React.RefAttributes<React.ComponentType<{
+}, "ref"> & RefAttributes<ComponentType<{
     [x: string]: unknown;
 }>>>;
 export declare const InputPhone: (props: InputPhoneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/popover-modal/popover-modal.d.ts

@@ -1,13 +1,13 @@
-import { default as React } from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
 export type PopoverBasicProps = {
-    trigger: React.ReactNode;
-    children: React.ReactNode;
+    trigger: ReactNode;
+    children: ReactNode;
     side?: "top" | "right" | "bottom" | "left";
     align?: "start" | "center" | "end";
     className?: string;
     triggerClassName?: string;
     open?: boolean;
     setOpen?: (value: boolean) => void;
-    triggerProps?: React.HTMLAttributes<HTMLElement>;
+    triggerProps?: HTMLAttributes<HTMLElement>;
 };
 export declare function PopoverBasic({ trigger, children, className, triggerClassName, side, align, open, setOpen, triggerProps, }: PopoverBasicProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/select-field/select-field.d.ts

@@ -1,5 +1,5 @@
 import { VariantProps } from 'class-variance-authority';
-import { default as React } from 'react';
+import { ComponentProps } from 'react';
 import { badgeVariants } from '../ui/badge';
 import { ComboboxChipsInput } from '../ui/combobox';
 export type SelectList = {
@@ -18,7 +18,7 @@ type SelectBaseProps = {
     description?: string;
     onChange?: (value: SelectValue) => void;
 };
-type SelectProps = SelectBaseProps & Omit<React.ComponentProps<typeof ComboboxChipsInput>, "list" | "onChange">;
+type SelectProps = SelectBaseProps & Omit<ComponentProps<typeof ComboboxChipsInput>, "list" | "onChange">;
 export declare const SelectField: {
     ({ list, label, multiple, disabled, isValid, description, onChange, ...rest }: SelectProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

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

@@ -1,11 +1,11 @@
 import { Avatar as AvatarPrimitive } from 'radix-ui';
-import * as React from "react";
-declare function Avatar({ className, size, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root> & {
+import { ComponentProps } from 'react';
+declare function Avatar({ className, size, ...props }: ComponentProps<typeof AvatarPrimitive.Root> & {
     size?: "default" | "sm" | "lg";
 }): import("react/jsx-runtime").JSX.Element;
-declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
-declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
-declare function AvatarBadge({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
-declare function AvatarGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function AvatarGroupCount({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, ...props }: ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarBadge({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroup({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
 export { Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage, };

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

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
+import { HTMLAttributes } from 'react';
 import { badgeVariants } from './badge.styles';
-import * as React from "react";
-export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "className">, VariantProps<typeof badgeVariants> {
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLDivElement>, "className">, VariantProps<typeof badgeVariants> {
     dotPosition?: "left" | "right";
     classNames?: {
         dotClassName?: string;

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

@@ -1,9 +1,9 @@
 import { VariantProps } from 'class-variance-authority';
+import { ButtonHTMLAttributes, Ref } from 'react';
 import { buttonVariants } from './button.styles';
-import * as React from "react";
-export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
-    ref?: React.Ref<HTMLButtonElement>;
+    ref?: Ref<HTMLButtonElement>;
 }
 declare const Button: {
     ({ className, variant, size, asChild, ref, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,23 +1,23 @@
+import { ComponentProps, ReactNode } from 'react';
 import { DayPicker, DayButton } from 'react-day-picker';
 import { Button } from '../button';
-import * as React from "react";
 type CalendarSize = "sm" | "md" | "lg";
 type CalendarPreset = {
     text: string;
     days: number;
 };
-type Props = React.ComponentProps<typeof DayPicker> & {
-    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+type Props = ComponentProps<typeof DayPicker> & {
+    buttonVariant?: ComponentProps<typeof Button>["variant"];
     size?: CalendarSize;
     classNameWrapper?: string;
     classNameFooter?: string;
-    footer?: React.ReactNode;
-    appendFooter?: React.ReactNode;
+    footer?: ReactNode;
+    appendFooter?: ReactNode;
     presets?: CalendarPreset[];
     presetBaseDate?: Date;
     onPresetClick?: (preset: CalendarPreset, date: Date) => void;
 };
 declare function Calendar({ className, classNames, classNameWrapper, classNameFooter, showOutsideDays, captionLayout, buttonVariant, size, locale, formatters, components, footer, appendFooter, presets, presetBaseDate, onPresetClick, onDayClick, ...props }: Props): import("react/jsx-runtime").JSX.Element;
-declare function CalendarDayButton({ className, day, modifiers, children, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, children, ...props }: ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
 export { Calendar, CalendarDayButton };
 export type { CalendarPreset, Props as CalendarProps };

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

@@ -57,6 +57,6 @@ export declare const calendarDayTextVariants: (props?: ({
 export declare const calendarFooterVariants: (props?: ({
     size?: "lg" | "md" | "sm" | null | undefined;
 } & ClassProp) | undefined) => string;
-export declare const calendarIconClassName = "text-primary-text !size-5";
+export declare const calendarIconClassName = "text-primary-text cursor-pointer";
 export declare const calendarWeekNumberCellClassName = "flex size-(--cell-size) items-center justify-center text-center";
 export declare const calendarDayTextClassName = "leading-none";

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

@@ -1,9 +1,9 @@
+import { HTMLAttributes, RefObject } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { cardVariants } from './card.styles';
-import * as React from "react";
 declare const Card: {
-    ({ ref, className, variant, disabled, active, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, variant, disabled, active, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
         variant?: VariantProps<typeof cardVariants>["variant"];
         disabled?: boolean;
         active?: boolean;
@@ -11,32 +11,32 @@ declare const Card: {
     displayName: string;
 };
 declare const CardHeader: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardTitle: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardDescription: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardContent: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardFooter: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

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

@@ -1,43 +1,45 @@
-import * as React from "react";
+import { ComponentProps, ComponentType, ReactNode, MemoExoticComponent } from 'react';
+import { LegendPayload, VerticalAlignmentType } from 'recharts/types/component/DefaultLegendContent';
+import { Payload as TooltipPayloadEntry, ValueType as TooltipValueType, NameType as TooltipNameType } from 'recharts/types/component/DefaultTooltipContent';
 import * as RechartsPrimitive from "recharts";
 declare const THEMES: {
     readonly light: "";
     readonly dark: ".dark";
 };
-export type ChartConfig = {
-    [k in string]: {
-        label?: React.ReactNode;
-        icon?: React.ComponentType<any>;
-    } & ({
-        color?: string;
-        theme?: never;
-    } | {
-        color?: never;
-        theme: Record<keyof typeof THEMES, string>;
-    });
-};
-declare function ChartContainer({ id, className, children, config, ...props }: React.ComponentProps<"div"> & {
+type ChartConfigItem = {
+    label?: ReactNode;
+    icon?: ComponentType;
+} & ({
+    color?: string;
+    theme?: never;
+} | {
+    color?: never;
+    theme: Record<keyof typeof THEMES, string>;
+});
+export type ChartConfig = Partial<Record<string, ChartConfigItem>>;
+declare function ChartContainer({ id, className, children, config, ...props }: ComponentProps<"div"> & {
     config: ChartConfig;
-    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+    children: ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
 }): import("react/jsx-runtime").JSX.Element;
 declare const ChartStyle: ({ id, config }: {
     id: string;
     config: ChartConfig;
 }) => import("react/jsx-runtime").JSX.Element | null;
 declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
-declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: React.ComponentProps<typeof RechartsPrimitive.Tooltip> & React.ComponentProps<"div"> & {
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: ComponentProps<typeof RechartsPrimitive.Tooltip> & ComponentProps<"div"> & {
     hideLabel?: boolean;
     hideIndicator?: boolean;
     indicator?: "line" | "dot" | "dashed";
     nameKey?: string;
     labelKey?: string;
-    payload?: any[];
-    label?: any;
+    payload?: ReadonlyArray<TooltipPayloadEntry<TooltipValueType, TooltipNameType>>;
+    label?: ReactNode;
 }): import("react/jsx-runtime").JSX.Element | null;
-declare const ChartLegend: React.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React.ReactPortal | null>;
-declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React.ComponentProps<"div"> & Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+declare const ChartLegend: MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React.ReactPortal | null>;
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: ComponentProps<"div"> & {
+    payload?: ReadonlyArray<LegendPayload>;
+    verticalAlign?: VerticalAlignmentType;
     hideIcon?: boolean;
     nameKey?: string;
-    payload?: any[];
 }): import("react/jsx-runtime").JSX.Element | null;
 export { ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, };

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

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

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

@@ -1,11 +1,11 @@
 import { Combobox as ComboboxPrimitive } from '@base-ui/react';
+import { ComponentProps, ComponentPropsWithRef, ReactNode } from 'react';
 import { Field } from '../field';
-import * as React from "react";
 declare function Combobox<Value, Multiple extends boolean | undefined = false>({ children, ...props }: ComboboxPrimitive.Root.Props<Value, Multiple>): import("react/jsx-runtime").JSX.Element;
-declare function ComboboxField({ className, label, description, error, children, ...props }: React.ComponentProps<typeof Field> & {
-    label?: React.ReactNode;
-    description?: React.ReactNode;
-    error?: React.ReactNode;
+declare function ComboboxField({ className, label, description, error, children, ...props }: ComponentProps<typeof Field> & {
+    label?: ReactNode;
+    description?: ReactNode;
+    error?: ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
 declare function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props): import("react/jsx-runtime").JSX.Element;
 declare function ComboboxTrigger({ className, children, ...props }: ComboboxPrimitive.Trigger.Props): import("react/jsx-runtime").JSX.Element;
@@ -23,7 +23,7 @@ declare function ComboboxLabel({ className, ...props }: ComboboxPrimitive.GroupL
 declare function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props): import("react/jsx-runtime").JSX.Element;
 declare function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props): import("react/jsx-runtime").JSX.Element;
 declare function ComboboxSeparator({ className, ...props }: ComboboxPrimitive.Separator.Props): import("react/jsx-runtime").JSX.Element;
-declare function ComboboxChips({ className, disabled, ...props }: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> & ComboboxPrimitive.Chips.Props & {
+declare function ComboboxChips({ className, disabled, ...props }: ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> & ComboboxPrimitive.Chips.Props & {
     disabled?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
 declare function ComboboxChip({ className, children, showRemove, ...props }: ComboboxPrimitive.Chip.Props & {

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

@@ -1,15 +1,15 @@
+import { ComponentPropsWithRef, HTMLAttributes, FC, ForwardRefExoticComponent, RefAttributes } from 'react';
 import * as DialogPrimitive from "@radix-ui/react-dialog";
-import * as React from "react";
-type DialogOverlayProps = React.ComponentPropsWithRef<typeof DialogPrimitive.Overlay>;
-type DialogContentProps = React.ComponentPropsWithRef<typeof DialogPrimitive.Content> & {
+type DialogOverlayProps = ComponentPropsWithRef<typeof DialogPrimitive.Overlay>;
+type DialogContentProps = ComponentPropsWithRef<typeof DialogPrimitive.Content> & {
     showCloseButton?: boolean;
 };
-type DialogTitleProps = React.ComponentPropsWithRef<typeof DialogPrimitive.Title>;
-type DialogDescriptionProps = React.ComponentPropsWithRef<typeof DialogPrimitive.Description>;
-declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
-declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
-declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+type DialogTitleProps = ComponentPropsWithRef<typeof DialogPrimitive.Title>;
+type DialogDescriptionProps = ComponentPropsWithRef<typeof DialogPrimitive.Description>;
+declare const Dialog: FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & RefAttributes<HTMLButtonElement>>;
 declare const DialogOverlay: {
     ({ className, ...props }: DialogOverlayProps): import("react/jsx-runtime").JSX.Element;
     displayName: string | undefined;
@@ -19,11 +19,11 @@ declare const DialogContent: {
     displayName: string | undefined;
 };
 declare const DialogHeader: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const DialogFooter: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const DialogTitle: {

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

@@ -1,13 +1,13 @@
+import { ComponentProps } from 'react';
 import { Drawer as DrawerPrimitive } from 'vaul';
-import * as React from "react";
-declare function Drawer({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerTrigger({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerPortal({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerClose({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerOverlay({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerContent({ className, children, ...props }: React.ComponentProps<typeof DrawerPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function DrawerFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function DrawerTitle({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
-declare function DrawerDescription({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function Drawer({ ...props }: ComponentProps<typeof DrawerPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerTrigger({ ...props }: ComponentProps<typeof DrawerPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerPortal({ ...props }: ComponentProps<typeof DrawerPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerClose({ ...props }: ComponentProps<typeof DrawerPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerOverlay({ className, ...props }: ComponentProps<typeof DrawerPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerContent({ className, children, ...props }: ComponentProps<typeof DrawerPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerHeader({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DrawerFooter({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DrawerTitle({ className, ...props }: ComponentProps<typeof DrawerPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerDescription({ className, ...props }: ComponentProps<typeof DrawerPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
 export { Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, };