@ostack.tech/ui 0.1.2 → 0.2.1

package/dist/types/components/Collapsible/CollapsibleContent.d.ts

@@ -1,7 +1,7 @@
 import { Collapsible as CollapsiblePrimitive } from "radix-ui";
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 /** Properties of the collapsible content component. */
-export interface CollapsibleContentProps extends React.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Content> {
+export interface CollapsibleContentProps extends ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Content> {
 }
 /** Component containing the collapsible content. */
-export declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/Collapsible/CollapsibleContext.d.ts

@@ -1,4 +1,3 @@
-import * as React from "react";
 import { type CollapsibleDirection } from "./Collapsible.tsx";
 /** Value of the collapsible context. */
 export interface CollapsibleContextValue {
@@ -6,6 +5,6 @@ export interface CollapsibleContextValue {
     direction: CollapsibleDirection;
 }
 /** Collapsible context. */
-export declare const CollapsibleContext: React.Context<CollapsibleContextValue | null>;
+export declare const CollapsibleContext: import("react").Context<CollapsibleContextValue | null>;
 /** Hook providing access to the collapsible context. */
 export declare function useCollapsibleContext(): CollapsibleContextValue;

package/dist/types/components/Collapsible/CollapsibleTrigger.d.ts

@@ -1,10 +1,10 @@
 import { Collapsible as CollapsiblePrimitive } from "radix-ui";
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 /** Properties of the collapsible trigger component. */
-export interface CollapsibleTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Trigger>, "asChild" | "children"> {
+export interface CollapsibleTriggerProps extends Omit<ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Trigger>, "asChild" | "children"> {
     defaultTriggerCollapseLabel?: string;
     defaultTriggerExpandLabel?: string;
-    children?: React.ReactNode | ((open: boolean) => React.ReactNode);
+    children?: ReactNode | ((open: boolean) => ReactNode);
 }
 /** Trigger that toggles the expansion of the collapsible content. */
-export declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/components/CommandMenu/CommandMenu.d.ts

@@ -1,5 +1,5 @@
 import { Command as CommandPrimitive } from "cmdk";
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ComponentPropsWithRef, type ReactNode } from "react";
 import { ControlAddon } from "../ControlAddon";
 import { Icon } from "../Icon";
 import { Input } from "../Input";
@@ -10,7 +10,7 @@ export type CommandMenuVariant = MenuListVariant;
 /** Placement of icons within command menu items. */
 export type CommandMenuIconPlacement = MenuListIconPlacement;
 /** Properties of the command menu component. */
-export interface CommandMenuProps extends React.ComponentPropsWithoutRef<typeof CommandPrimitive> {
+export interface CommandMenuProps extends ComponentPropsWithoutRef<typeof CommandPrimitive> {
     /**
      * Style variant of the command menu list.
      *
@@ -43,21 +43,21 @@ export interface CommandMenuProps extends React.ComponentPropsWithoutRef<typeof
     /** Estimated progress of loading the list of items. */
     loadingProgress?: number;
     /** Message to display when no items were found. */
-    emptyMessage?: React.ReactNode;
+    emptyMessage?: ReactNode;
     /** Properties to pass to the search `Input` component. */
-    searchProps?: Omit<React.ComponentPropsWithRef<typeof Input>, "asChild" | "variant" | "status" | "code" | "defaultValue" | "value" | "onValueChange" | "startAdornment" | "endAdornment" | "showClearButton">;
+    searchProps?: Omit<ComponentPropsWithRef<typeof Input>, "asChild" | "variant" | "status" | "code" | "defaultValue" | "value" | "onValueChange" | "startAdornment" | "endAdornment" | "showClearButton">;
     /** Properties to pass to the search adornment `ControlAddon` component. */
-    searchAdornmentProps?: React.ComponentPropsWithRef<typeof ControlAddon>;
+    searchAdornmentProps?: ComponentPropsWithRef<typeof ControlAddon>;
     /** Properties to pass to the search `Icon` component. */
-    searchIconProps?: React.ComponentPropsWithRef<typeof Icon>;
+    searchIconProps?: ComponentPropsWithRef<typeof Icon>;
     /** Properties to pass to the list component. */
-    listProps?: Omit<React.ComponentPropsWithRef<typeof MenuList>, "asChild" | "variant" | "iconPlacement">;
+    listProps?: Omit<ComponentPropsWithRef<typeof MenuList>, "asChild" | "variant" | "iconPlacement">;
     /** Properties to pass to the loading element. */
-    loadingProps?: React.ComponentPropsWithRef<"div">;
+    loadingProps?: ComponentPropsWithRef<"div">;
     /** Properties to pass to the spinner component. */
-    spinnerProps?: React.ComponentPropsWithRef<typeof Spinner>;
+    spinnerProps?: ComponentPropsWithRef<typeof Spinner>;
     /** Properties to pass to the component containing the empty message. */
-    emptyMessageProps?: React.ComponentPropsWithRef<"div">;
+    emptyMessageProps?: ComponentPropsWithRef<"div">;
 }
 /**
  * The command menu renders a menu of selectable items which can be filtered and
@@ -88,4 +88,4 @@ export interface CommandMenuProps extends React.ComponentPropsWithoutRef<typeof
  * }
  * ```
  */
-export declare const CommandMenu: React.ForwardRefExoticComponent<CommandMenuProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CommandMenu: import("react").ForwardRefExoticComponent<CommandMenuProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/CommandMenu/CommandMenuDialog.d.ts

@@ -1,15 +1,15 @@
 import { Dialog as DialogPrimitive } from "radix-ui";
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ComponentPropsWithRef, type ReactNode } from "react";
 import { type DialogContentSize } from "../Dialog";
 import { Overlay } from "../Overlay";
 /** Possible command menu dialog sizes. */
 export type CommandMenuDialogSize = DialogContentSize;
 /** Properties of the command menu dialog. */
-export interface CommandMenuDialogProps extends Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, "asChild" | "title"> {
+export interface CommandMenuDialogProps extends Omit<ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, "asChild" | "title"> {
     /** Accessible dialog title. Not shown visibly. */
-    title?: React.ReactNode;
+    title?: ReactNode;
     /** Accessible dialog description. Not shown visibly. */
-    description?: React.ReactNode;
+    description?: ReactNode;
     /**
      * Size of the command menu dialog.
      *
@@ -37,9 +37,9 @@ export interface CommandMenuDialogProps extends Omit<React.ComponentPropsWithout
      */
     modal?: boolean;
     /** Properties to pass to the portal component. */
-    portalProps?: Omit<React.ComponentPropsWithRef<typeof DialogPrimitive.Portal>, "forceMount">;
+    portalProps?: Omit<ComponentPropsWithRef<typeof DialogPrimitive.Portal>, "forceMount">;
     /** Properties to pass to the `Overlay` component. */
-    overlayProps?: React.ComponentPropsWithRef<typeof Overlay>;
+    overlayProps?: ComponentPropsWithRef<typeof Overlay>;
 }
 /** Component used to display the command menu within a dialog. */
-export declare const CommandMenuDialog: React.ForwardRefExoticComponent<CommandMenuDialogProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CommandMenuDialog: import("react").ForwardRefExoticComponent<CommandMenuDialogProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/CommandMenu/CommandMenuGroup.d.ts

@@ -1,9 +1,9 @@
 import { Command as CommandPrimitive } from "cmdk";
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 /** Properties of the command menu group. */
-export interface CommandMenuGroupProps extends Omit<React.ComponentPropsWithoutRef<typeof CommandPrimitive.Group>, "asChild" | "heading"> {
+export interface CommandMenuGroupProps extends Omit<ComponentPropsWithoutRef<typeof CommandPrimitive.Group>, "asChild" | "heading"> {
     /** Optional label of the command menu group. */
-    label?: React.ReactNode;
+    label?: ReactNode;
 }
 /** Component used to group multiple command items. */
-export declare const CommandMenuGroup: React.ForwardRefExoticComponent<CommandMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CommandMenuGroup: import("react").ForwardRefExoticComponent<CommandMenuGroupProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/CommandMenu/CommandMenuItem.d.ts

@@ -1,7 +1,7 @@
 import { Command as CommandPrimitive } from "cmdk";
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { type MenuListItemProps } from "../MenuList";
-export interface CommandMenuItemProps extends Omit<React.ComponentPropsWithoutRef<typeof CommandPrimitive.Item>, "asChild" | "color">, Pick<MenuListItemProps, "selected" | "color" | "loading" | "enabledWhenLoading" | "loadingContent" | "icon" | "iconPlacement" | "href" | "target" | "rel" | "actionProps" | "contentProps" | "iconProps" | "spinnerProps"> {
+export interface CommandMenuItemProps extends Omit<ComponentPropsWithoutRef<typeof CommandPrimitive.Item>, "asChild" | "color">, Pick<MenuListItemProps, "selected" | "color" | "loading" | "enabledWhenLoading" | "loadingContent" | "icon" | "iconPlacement" | "href" | "target" | "rel" | "actionProps" | "contentProps" | "iconProps" | "spinnerProps"> {
     /**
      * Render the item as a link. When set, you can pass `href`, `target`, and
      * `rel` properties to the item.
@@ -10,4 +10,4 @@ export interface CommandMenuItemProps extends Omit<React.ComponentPropsWithoutRe
      */
     asLink?: boolean;
 }
-export declare const CommandMenuItem: React.ForwardRefExoticComponent<CommandMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CommandMenuItem: import("react").ForwardRefExoticComponent<CommandMenuItemProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/Container/Container.d.ts

@@ -1,10 +1,10 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { type Breakpoint } from "../../utils/breakpoints.ts";
 import { type Responsive } from "../../utils/useResponsiveValues.ts";
 /** Value specifying up to which breakpoint the container should be fluid. */
 export type ContainerFluidUntil = Omit<Breakpoint, "xs">;
 /** Properties of the container component. */
-export interface ContainerProps extends React.ComponentPropsWithoutRef<"div"> {
+export interface ContainerProps extends ComponentPropsWithoutRef<"div"> {
     /**
      * Change the component to the HTML tag or custom component of the only child.
      * This will merge the original component props with the props of the supplied
@@ -63,4 +63,4 @@ export interface ContainerProps extends React.ComponentPropsWithoutRef<"div"> {
  * }
  * ```
  */
-export declare const Container: React.ForwardRefExoticComponent<ContainerProps & React.RefAttributes<HTMLDivElement>>;
+export declare const Container: import("react").ForwardRefExoticComponent<ContainerProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/ControlAddon/ControlAddon.d.ts

@@ -1,7 +1,7 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { type ControlStatus, type ControlVariant } from "../../utils/control.ts";
 /** Properties of the control addon component. */
-export interface ControlAddonProps extends React.ComponentPropsWithoutRef<"div"> {
+export interface ControlAddonProps extends ComponentPropsWithoutRef<"div"> {
     /**
      * Change the component to the HTML tag or custom component of the only child.
      * This will merge the original component props with the props of the supplied
@@ -33,4 +33,4 @@ export interface ControlAddonProps extends React.ComponentPropsWithoutRef<"div">
  * `endAdornment` properties of a control, but can also be used standalone where
  * it makes sense.
  */
-export declare const ControlAddon: React.ForwardRefExoticComponent<ControlAddonProps & React.RefAttributes<HTMLDivElement>>;
+export declare const ControlAddon: import("react").ForwardRefExoticComponent<ControlAddonProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/ControlCode/ControlCode.d.ts

@@ -1,7 +1,7 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 import { type ControlStatus, type ControlVariant } from "../../utils/control.ts";
 /** Properties of the control's code component. */
-export interface ControlCodeProps extends React.ComponentPropsWithoutRef<"div"> {
+export interface ControlCodeProps extends ComponentPropsWithoutRef<"div"> {
     /**
      * Change the component to the HTML tag or custom component of the only child.
      * This will merge the original component props with the props of the supplied
@@ -16,7 +16,7 @@ export interface ControlCodeProps extends React.ComponentPropsWithoutRef<"div">
      */
     status?: ControlStatus;
     /** Text prefixed to the code to be announced by assistive technologies. */
-    visuallyHiddenPrefix?: React.ReactNode;
+    visuallyHiddenPrefix?: ReactNode;
 }
 /** Component used to display the "code" of a form control. */
-export declare const ControlCode: React.ForwardRefExoticComponent<ControlCodeProps & React.RefAttributes<HTMLDivElement>>;
+export declare const ControlCode: import("react").ForwardRefExoticComponent<ControlCodeProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DataTable/DataTable.d.ts

@@ -1,4 +1,4 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type Key, type ReactNode, type Ref } from "react";
 import { type SortDirection } from "../../utils/sorting.ts";
 import { type DataTableApi } from "./DataTableApi.ts";
 import { type DataTableCellProps } from "./DataTableCell.tsx";
@@ -41,7 +41,7 @@ export interface DataTableGetRowsResult<T = unknown> {
     totalCount: number;
 }
 /** Properties of the data table component. */
-export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<"div"> {
+export interface DataTableProps<T = any> extends ComponentPropsWithoutRef<"div"> {
     /**
      * Display mode of the data table. Rows are displayed either in pages or
      * within an infinite scroll component.
@@ -67,9 +67,9 @@ export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<
      * Property of the row that contains the row's key, or a function used to get
      * it, given the row.
      *
-     * Keys should be of type `React.Key`, i.e. `string | number | bigint`.
+     * Keys should be of type `Key`, i.e. `string | number | bigint`.
      */
-    rowKey: string | number | symbol | ((row: T) => React.Key);
+    rowKey: string | number | symbol | ((row: T) => Key);
     /**
      * Number of rows to show when `loading` is `true`, or using `getRows` and the
      * total count isn't yet known.
@@ -169,19 +169,19 @@ export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<
      */
     showSelectionColumn?: boolean;
     /** Default keys of the selected rows. */
-    defaultSelectedRows?: React.Key[];
+    defaultSelectedRows?: Key[];
     /**
      * Controlled keys of the selected rows.
      *
      * Use together with `onSelectedRowsChange` to change the selected rows.
      */
-    selectedRows?: React.Key[];
+    selectedRows?: Key[];
     /**
      * Function called whenever the selected rows of the data table change.
      *
      * @param selectedRows Array containing the keys of the newly selected rows.
      */
-    onSelectedRowsChange?: (selectedRows: React.Key[]) => void;
+    onSelectedRowsChange?: (selectedRows: Key[]) => void;
     /**
      * Function used to render each row. This function should typically return a
      * `DataTableRow` with the provided properties. This function is useful to
@@ -190,7 +190,7 @@ export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<
      * @default props => <DataTableRow {...props} />
      * @param props Properties to pass to the data table row to render.
      */
-    renderRow?: (props: DataTableRowProps) => React.ReactNode;
+    renderRow?: (props: DataTableRowProps) => ReactNode;
     /**
      * Function used to render each cell. This function should typically return a
      * `DataTableCell` with the provided properties. This function is useful to
@@ -199,7 +199,7 @@ export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<
      * @default props => <DataTableCell {...props} />
      * @param props Properties to pass to the data table cell to render.
      */
-    renderCell?: (props: DataTableCellProps) => React.ReactNode;
+    renderCell?: (props: DataTableCellProps) => ReactNode;
     /**
      * Whether the height of each row should be computed dynamically (only
      * relevant for scrolled mode).
@@ -224,7 +224,7 @@ export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<
      */
     overscan?: number;
     /** Reference to interact with the data table's API. */
-    apiRef?: React.Ref<DataTableApi<T> | undefined>;
+    apiRef?: Ref<DataTableApi<T> | undefined>;
 }
 /**
  * The `DataTable` component is the root component used for displaying a data
@@ -253,4 +253,4 @@ export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<
  *   component is only relevant when providing a custom data table cell via
  *   `renderCell`.
  */
-export declare const DataTable: React.ForwardRefExoticComponent<DataTableProps<any> & React.RefAttributes<HTMLDivElement>>;
+export declare const DataTable: import("react").ForwardRefExoticComponent<DataTableProps<any> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DataTable/DataTableApi.d.ts

@@ -1,5 +1,5 @@
 import { type ScrollToOptions } from "@tanstack/react-virtual";
-import * as React from "react";
+import { type RefObject } from "react";
 /** Options used when using the `goTo` function of the `DataTableApi`. */
 export type DataTableScrollToOptions = ScrollToOptions;
 /** Imperative data table API. */
@@ -34,4 +34,4 @@ export interface DataTableApi<T = unknown> {
     goTo: (index: number, scrollOptions?: DataTableScrollToOptions) => void;
 }
 /** Hook used to access the data table API. */
-export declare function useDataTableApiRef(): React.RefObject<DataTableApi | null>;
+export declare function useDataTableApiRef(): RefObject<DataTableApi | null>;

package/dist/types/components/DataTable/DataTableBody.d.ts

@@ -1,9 +1,9 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type RefObject } from "react";
 import { TableBody } from "../Table";
 import { type DataTableContentProps } from "./DataTableContent.tsx";
 /** Properties of the data table foot component. */
-export interface DataTableBodyProps extends React.ComponentPropsWithoutRef<typeof TableBody>, Pick<DataTableContentProps, "emptyMessage" | "emptyMessageProps"> {
-    containerRef: React.MutableRefObject<HTMLDivElement | null>;
+export interface DataTableBodyProps extends ComponentPropsWithoutRef<typeof TableBody>, Pick<DataTableContentProps, "emptyMessage" | "emptyMessageProps"> {
+    containerRef: RefObject<HTMLDivElement | null>;
 }
 /** Body of the data table. */
-export declare const DataTableBody: React.ForwardRefExoticComponent<DataTableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;
+export declare const DataTableBody: import("react").ForwardRefExoticComponent<DataTableBodyProps & import("react").RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/DataTable/DataTableCell.d.ts

@@ -1,9 +1,9 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 import { TableCell } from "../Table";
 /** Properties of a data table cell. */
-export interface DataTableCellProps extends React.ComponentPropsWithoutRef<typeof TableCell> {
-    columnLabel?: React.ReactNode;
+export interface DataTableCellProps extends ComponentPropsWithoutRef<typeof TableCell> {
+    columnLabel?: ReactNode;
     columnLabelId?: string;
 }
 /** Data table cell. */
-export declare const DataTableCell: React.ForwardRefExoticComponent<DataTableCellProps & React.RefAttributes<HTMLTableDataCellElement>>;
+export declare const DataTableCell: import("react").ForwardRefExoticComponent<DataTableCellProps & import("react").RefAttributes<HTMLTableDataCellElement>>;

package/dist/types/components/DataTable/DataTableColumn.d.ts

@@ -1,10 +1,10 @@
-import type * as React from "react";
+import { type ComponentPropsWithRef, type ReactNode } from "react";
 import { type MatchAgainstFilter } from "../../utils/filtering.ts";
 import { type TableColumn } from "../Table";
 /** Data table columns. */
 export type DataTableColumns<T = unknown> = Record<string, DataTableColumn<T>>;
 /** Data table column. */
-export interface DataTableColumn<T = unknown, TValue = any> extends Omit<React.ComponentPropsWithRef<typeof TableColumn>, "sorted" | "onSort"> {
+export interface DataTableColumn<T = unknown, TValue = any> extends Omit<ComponentPropsWithRef<typeof TableColumn>, "sorted" | "onSort"> {
     /**
      * Whether values of this column can be filtered.
      *
@@ -35,7 +35,7 @@ export interface DataTableColumn<T = unknown, TValue = any> extends Omit<React.C
      * Function used to render the cell's content. By default, the formatted value
      * is rendered, possibly highlighted when it matches the filter.
      */
-    render?: (renderData: DataTableColumnRenderData<T, TValue>) => React.ReactNode;
+    render?: (renderData: DataTableColumnRenderData<T, TValue>) => ReactNode;
     /**
      * Comparison function used when sorting values of this column. The default
      * sorting function can handle primitive values and dates. When sorting other
@@ -66,5 +66,5 @@ export interface DataTableColumnRenderData<T = unknown, TValue = unknown> extend
      * doesn't match the filter, this property will be the same as
      * `formattedValue`.
      */
-    markedValue: React.ReactNode;
+    markedValue: ReactNode;
 }

package/dist/types/components/DataTable/DataTableContent.d.ts

@@ -1,11 +1,11 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ComponentPropsWithRef, type ReactNode } from "react";
 import { Table, type TableBody, type TableFoot, type TableHead } from "../Table";
 /** Properties of the data table content component. */
-export interface DataTableContentProps extends Omit<React.ComponentPropsWithoutRef<typeof Table>, "layout"> {
+export interface DataTableContentProps extends Omit<ComponentPropsWithoutRef<typeof Table>, "layout"> {
     /** Message to display when the data table contains no rows. */
-    emptyMessage?: React.ReactNode;
+    emptyMessage?: ReactNode;
     /** Content of the table foot component. */
-    tableFootContent?: React.ReactNode;
+    tableFootContent?: ReactNode;
     /**
      * Whether the table foot show be shown when the data table is empty.
      *
@@ -13,16 +13,16 @@ export interface DataTableContentProps extends Omit<React.ComponentPropsWithoutR
      */
     showTableFootWhenEmpty?: boolean;
     /** Properties to pass to the table head component. */
-    tableHeadProps?: React.ComponentPropsWithRef<typeof TableHead>;
+    tableHeadProps?: ComponentPropsWithRef<typeof TableHead>;
     /** Properties to pass to the table body component. */
-    tableBodyProps?: React.ComponentPropsWithRef<typeof TableBody>;
+    tableBodyProps?: ComponentPropsWithRef<typeof TableBody>;
     /** Properties to pass to the table foot component, when one exists. */
-    tableFootProps?: React.ComponentPropsWithRef<typeof TableFoot>;
+    tableFootProps?: ComponentPropsWithRef<typeof TableFoot>;
     /** Properties to pass to the component containing the empty message. */
-    emptyMessageProps?: React.ComponentPropsWithRef<"div">;
+    emptyMessageProps?: ComponentPropsWithRef<"div">;
 }
 /**
  * Component containing the "main content" of the data table, i.e. the table
  * itself.
  */
-export declare const DataTableContent: React.ForwardRefExoticComponent<DataTableContentProps & React.RefAttributes<HTMLTableElement>>;
+export declare const DataTableContent: import("react").ForwardRefExoticComponent<DataTableContentProps & import("react").RefAttributes<HTMLTableElement>>;

package/dist/types/components/DataTable/DataTableContext.d.ts

@@ -1,4 +1,4 @@
-import * as React from "react";
+import { type Key, type ReactNode, type Ref } from "react";
 import { type SortDirection } from "../../utils/sorting.ts";
 import { type DataTableDisplayMode, type DataTableGetRowsOptions, type DataTableGetRowsResult } from "./DataTable.tsx";
 import { type DataTableApi } from "./DataTableApi.ts";
@@ -8,16 +8,16 @@ import { type DataTableRowProps } from "./DataTableRow.tsx";
 /** Value of the data table context. */
 export interface DataTableContextValue<T = any> {
     displayMode: DataTableDisplayMode;
-    rowKey: string | number | symbol | ((row: T) => React.Key);
+    rowKey: string | number | symbol | ((row: T) => Key);
     required?: boolean;
     showSelectionColumn: boolean;
-    renderRow?: (props: DataTableRowProps) => React.ReactNode;
-    renderCell?: (props: DataTableCellProps) => React.ReactNode;
+    renderRow?: (props: DataTableRowProps) => ReactNode;
+    renderCell?: (props: DataTableCellProps) => ReactNode;
     dynamicRowHeight: boolean;
     estimatedRowHeight: number | ((index: number) => number);
     overscan: number;
     generatedId: string;
-    apiRef?: React.Ref<DataTableApi<T> | undefined>;
+    apiRef?: Ref<DataTableApi<T> | undefined>;
     store: DataTableStore<T>;
 }
 /** State of the data table. */
@@ -51,7 +51,7 @@ export interface DataTableState<T = any> {
     filter: string;
     sortBy: string | null;
     sortDirection: SortDirection;
-    selectedRows: [Set<React.Key>];
+    selectedRows: [Set<Key>];
     scrolledRangeStart: number;
     scrolledRangeEnd: number;
     tableHeadHeight?: number;
@@ -65,8 +65,8 @@ export interface DataTableActions<T> {
     setLimit: (limit: number) => void;
     setFilter: (filter: string) => void;
     setSort: (sortBy: string | null, sortDirection: SortDirection) => void;
-    selectRows: (keys: React.Key[]) => void;
-    unselectRows: (keys: React.Key[]) => void;
+    selectRows: (keys: Key[]) => void;
+    unselectRows: (keys: Key[]) => void;
     updateWindow: (offset: number, limit: number) => void;
     spliceWindow: (offset: number, limit: number, startIndex: number, deleted?: number, added?: number | T[]) => void;
     refresh: (newTotalCount?: number | null) => void;
@@ -74,7 +74,7 @@ export interface DataTableActions<T> {
 /** Data table store. */
 export type DataTableStore<T> = ReturnType<typeof useCreateDataTableContext<T>>["store"];
 /** Data table context. */
-export declare const DataTableContext: React.Context<DataTableContextValue<any> | null>;
+export declare const DataTableContext: import("react").Context<DataTableContextValue<any> | null>;
 /** Options used to create the data table context value. */
 export interface UseCreateDataTableContextOptions<T> extends Omit<DataTableContextValue, "generatedId" | "store"> {
     columns: DataTableColumns<T>;
@@ -99,23 +99,23 @@ export interface UseCreateDataTableContextOptions<T> extends Omit<DataTableConte
     sortDirection?: SortDirection;
     onSort?: (sortBy: string | null, sortDirection: SortDirection) => void;
     showSelectionColumn: boolean;
-    defaultSelectedRows?: React.Key[];
-    selectedRows?: React.Key[];
-    onSelectedRowsChange?: (selectedRows: React.Key[]) => void;
+    defaultSelectedRows?: Key[];
+    selectedRows?: Key[];
+    onSelectedRowsChange?: (selectedRows: Key[]) => void;
 }
 /** Hook which creates the data table context value. */
 export declare function useCreateDataTableContext<T>({ displayMode, columns, rows, getRows, rowKey, loadingCount, required, loading, renderRow, renderCell, dynamicRowHeight, estimatedRowHeight, overscan, apiRef, leafColumns, headCount, defaultOffset, offset, onOffsetChange, defaultLimit, limit, onLimitChange, defaultFilter, filter, onFilterChange, defaultSortBy, sortBy, defaultSortDirection, sortDirection, onSort, showSelectionColumn, defaultSelectedRows, selectedRows, onSelectedRowsChange, }: UseCreateDataTableContextOptions<T>): {
     displayMode: DataTableDisplayMode;
-    rowKey: string | number | symbol | ((row: any) => React.Key);
+    rowKey: string | number | symbol | ((row: any) => Key);
     required: boolean | undefined;
     showSelectionColumn: boolean;
-    renderRow: ((props: DataTableRowProps) => React.ReactNode) | undefined;
-    renderCell: ((props: DataTableCellProps) => React.ReactNode) | undefined;
+    renderRow: ((props: DataTableRowProps) => ReactNode) | undefined;
+    renderCell: ((props: DataTableCellProps) => ReactNode) | undefined;
     dynamicRowHeight: boolean;
     estimatedRowHeight: number | ((index: number) => number);
     overscan: number;
     generatedId: string;
-    apiRef: React.Ref<DataTableApi<any> | undefined> | undefined;
+    apiRef: Ref<DataTableApi<any> | undefined> | undefined;
     store: Omit<import("zustand").StoreApi<DataTableState<T>>, "subscribe"> & {
         subscribe: {
             (listener: (selectedState: DataTableState<T>, previousSelectedState: DataTableState<T>) => void): () => void;
@@ -130,12 +130,12 @@ export declare function useCreateDataTableContext<T>({ displayMode, columns, row
 export declare function useDataTableContext<T = unknown>(): DataTableContextValue<T>;
 /** Context value of a data table cell. */
 export interface DataTableCellContextValue {
-    columnLabel?: React.ReactNode;
+    columnLabel?: ReactNode;
     columnLabelId?: string;
 }
 /** Data table cell context. */
-export declare const DataTableCellContext: React.Context<DataTableCellContextValue | null>;
+export declare const DataTableCellContext: import("react").Context<DataTableCellContextValue | null>;
 /** Column label accessible within a data table cell. */
-export declare function useDataTableColumnLabel(): React.ReactNode;
+export declare function useDataTableColumnLabel(): ReactNode;
 /** Column label id accessible within a data table cell. */
 export declare function useDataTableColumnLabelId(): string | null;

package/dist/types/components/DataTable/DataTableFilter.d.ts

@@ -1,7 +1,7 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { Input } from "../Input";
 /** Properties of the data table filter component. */
-export interface DataTableFilterProps extends Omit<React.ComponentPropsWithoutRef<typeof Input>, "defaultValue" | "value"> {
+export interface DataTableFilterProps extends Omit<ComponentPropsWithoutRef<typeof Input>, "defaultValue" | "value"> {
 }
 /** Input used to globally filter a data table. */
-export declare const DataTableFilter: React.ForwardRefExoticComponent<DataTableFilterProps & React.RefAttributes<HTMLInputElement>>;
+export declare const DataTableFilter: import("react").ForwardRefExoticComponent<DataTableFilterProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/types/components/DataTable/DataTableFoot.d.ts

@@ -1,8 +1,8 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { TableFoot } from "../Table";
 /** Properties of the data table foot component. */
-export interface DataTableFootProps extends React.ComponentPropsWithoutRef<typeof TableFoot> {
+export interface DataTableFootProps extends ComponentPropsWithoutRef<typeof TableFoot> {
     showWhenEmpty: boolean;
 }
 /** Foot of the data table. */
-export declare const DataTableFoot: React.ForwardRefExoticComponent<DataTableFootProps & React.RefAttributes<HTMLTableSectionElement>>;
+export declare const DataTableFoot: import("react").ForwardRefExoticComponent<DataTableFootProps & import("react").RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/DataTable/DataTableHead.d.ts

@@ -1,7 +1,7 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { TableHead } from "../Table";
 /** Properties of the data table head component. */
-export interface DataTableHeadProps extends React.ComponentPropsWithoutRef<typeof TableHead> {
+export interface DataTableHeadProps extends ComponentPropsWithoutRef<typeof TableHead> {
 }
 /** Head of the data table. */
-export declare const DataTableHead: React.ForwardRefExoticComponent<DataTableHeadProps & React.RefAttributes<HTMLTableSectionElement>>;
+export declare const DataTableHead: import("react").ForwardRefExoticComponent<DataTableHeadProps & import("react").RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/DataTable/DataTablePagination.d.ts

@@ -1,6 +1,6 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 /** Properties of the data table pagination component. */
-export interface DataTablePaginationProps extends React.ComponentPropsWithoutRef<"div"> {
+export interface DataTablePaginationProps extends ComponentPropsWithoutRef<"div"> {
     /**
      * Function used to render the range of displayed rows.
      *
@@ -8,11 +8,11 @@ export interface DataTablePaginationProps extends React.ComponentPropsWithoutRef
      *   this is a select).
      * @param total Total number of rows.
      */
-    rowsRange?: (range: React.ReactNode, total: number) => React.ReactNode;
+    rowsRange?: (range: ReactNode, total: number) => ReactNode;
     /** Label of the previous page button (only relevant in paged mode). */
     previousPageButtonLabel?: string;
     /** Label of the next page button (only relevant in paged mode). */
     nextPageButtonLabel?: string;
 }
 /** Component used to provide pagination to the data table. */
-export declare const DataTablePagination: React.ForwardRefExoticComponent<DataTablePaginationProps & React.RefAttributes<HTMLDivElement>>;
+export declare const DataTablePagination: import("react").ForwardRefExoticComponent<DataTablePaginationProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/DataTable/DataTableRow.d.ts

@@ -1,11 +1,11 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef } from "react";
 import { TableRow } from "../Table";
 /** Properties of a data table row. */
-export interface DataTableRowProps<T = any> extends React.ComponentPropsWithoutRef<typeof TableRow> {
+export interface DataTableRowProps<T = any> extends ComponentPropsWithoutRef<typeof TableRow> {
     /** Row data. When `undefined`, the row is rendered as "loading". */
     row: T | undefined;
     /** Row index. */
     index: number;
 }
 /** Data table row. */
-export declare const DataTableRow: React.NamedExoticComponent<DataTableRowProps<any> & React.RefAttributes<HTMLTableRowElement>>;
+export declare const DataTableRow: import("react").NamedExoticComponent<DataTableRowProps<any> & import("react").RefAttributes<HTMLTableRowElement>>;

package/dist/types/components/DataTable/DataTableRowsPerPage.d.ts

@@ -1,6 +1,6 @@
-import * as React from "react";
+import { type ComponentPropsWithoutRef, type ReactNode } from "react";
 /** Properties of the data table rows per page component. */
-export interface DataTableRowsPerPageProps extends React.ComponentPropsWithoutRef<"div"> {
+export interface DataTableRowsPerPageProps extends ComponentPropsWithoutRef<"div"> {
     /**
      * Options used to set the data table's `limit` (the maximum number of rows
      * shown per page).
@@ -13,7 +13,7 @@ export interface DataTableRowsPerPageProps extends React.ComponentPropsWithoutRe
      *
      * @param rows Node representing the number of rows (a select).
      */
-    label?: React.ReactNode;
+    label?: ReactNode;
 }
 /** Component displaying a select used to change the number of rows per page. */
-export declare const DataTableRowsPerPage: React.ForwardRefExoticComponent<DataTableRowsPerPageProps & React.RefAttributes<HTMLDivElement>>;
+export declare const DataTableRowsPerPage: import("react").ForwardRefExoticComponent<DataTableRowsPerPageProps & import("react").RefAttributes<HTMLDivElement>>;