@veritone-ce/design-system 2.8.14-next.2.0 → 2.8.14

package/dist/types/Icon/shared.d.ts

@@ -0,0 +1,10 @@
+import React, { type ForwardRefExoticComponent } from 'react';
+import type { IconSize } from './wrappers.js';
+export type CommonIconProps<ExtraProps extends object = {}> = {
+    name?: string;
+    size?: IconSize;
+    'data-testid'?: string;
+    style?: React.CSSProperties;
+    className?: string;
+} & ExtraProps;
+export type GenericIconComponent<ExtraProps extends object = {}> = ForwardRefExoticComponent<CommonIconProps<ExtraProps> & React.RefAttributes<HTMLSpanElement>>;

package/dist/types/Icon/wrappers.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { GenericIconComponent } from './shared.js';
+import type { SvgIconProps } from '@mui/material';
+export type IconSize = 'large' | 'medium' | 'small' | 'inherit';
+export declare function adaptMuiSvgIcon(MuiIcon: React.ComponentType<SvgIconProps>): GenericIconComponent;
+export declare function adaptSvgIcon(svg: React.JSX.Element): GenericIconComponent;

package/dist/types/IconButton/index.d.ts

@@ -0,0 +1,18 @@
+import React, { MouseEventHandler } from 'react';
+import { type PaletteActionVariantsColors, type ResolvablePaletteValue } from '../styles/index.js';
+export type IconButtonVariant = 'primary' | 'secondary';
+export type IconButtonPalette = ResolvablePaletteValue<PaletteActionVariantsColors>;
+export type IconButtonProps = {
+    variant?: IconButtonVariant;
+    palette?: IconButtonPalette;
+    disabled?: boolean;
+    loading?: boolean;
+    type?: React.ButtonHTMLAttributes<HTMLButtonElement>['type'];
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+    children?: React.ReactNode;
+    'data-testid'?: string;
+    style?: React.CSSProperties;
+    className?: string;
+};
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export default IconButton;

package/dist/types/Input/index.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export type InputProps = React.ComponentPropsWithoutRef<'input'> & {
+    placeholder?: string | undefined;
+    value?: string | ReadonlyArray<string> | number | undefined;
+    error?: boolean;
+    disabled?: boolean;
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+    'data-testid'?: string;
+    style?: React.CSSProperties;
+    className?: string;
+};
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & {
+    placeholder?: string | undefined;
+    value?: string | ReadonlyArray<string> | number | undefined;
+    error?: boolean | undefined;
+    disabled?: boolean | undefined;
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+    'data-testid'?: string | undefined;
+    style?: React.CSSProperties | undefined;
+    className?: string | undefined;
+} & React.RefAttributes<HTMLInputElement>>;
+export default Input;

package/dist/types/Menu/controlled.d.ts

@@ -0,0 +1,56 @@
+import React from 'react';
+import { type PopoverAnchor, type PopoverPlacement, type PopoverStrategy, type PopoverPortalElProp } from '../popover/index.js';
+export type MenuOption = {
+    label: string;
+    render?: React.ReactNode;
+    icon?: React.ReactNode;
+    onSelect(e: React.MouseEvent<HTMLButtonElement>): void;
+    'data-pendo'?: string;
+    disabled?: boolean;
+    options?: MenuOption[];
+};
+export type MenuRole = 'tooltip' | 'dialog' | 'alertdialog' | 'menu' | 'listbox' | 'grid' | 'tree' | 'select' | 'label' | 'combobox';
+export type MenuVirtualizeOptions = {
+    itemSize?: number;
+    overscan?: number;
+    maxHeight?: number;
+};
+export type MenuProps = {
+    anchor?: PopoverAnchor;
+    anchorId?: string;
+    portalEl?: PopoverPortalElProp;
+    open: boolean;
+    role?: MenuRole;
+    placement?: PopoverPlacement;
+    strategy?: PopoverStrategy;
+    disableAutoFocus?: boolean;
+    enableTypeahead?: boolean;
+    matchAnchorWidth?: boolean;
+    virtualize?: boolean | MenuVirtualizeOptions;
+    onReachEnd?: () => void;
+    reachEndOffset?: number;
+    options: MenuOption[];
+    dismissEnabled?: boolean;
+    onDismiss?: () => void;
+    'data-testid'?: string;
+    style?: React.CSSProperties;
+    className?: string;
+};
+declare function Menu({ open: isOpen, role: assumeRole, placement, strategy, enableTypeahead, matchAnchorWidth, virtualize, onReachEnd, reachEndOffset, options, dismissEnabled, disableAutoFocus, className, ...props }: MenuProps): import("react/jsx-runtime").JSX.Element;
+export type MenuItemProps = {
+    label?: string;
+    render?: React.ReactNode;
+    icon?: React.ReactNode;
+    isActive: boolean;
+    disabled?: boolean;
+    'data-pendo'?: string;
+};
+export declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.ButtonHTMLAttributes<HTMLButtonElement> & React.RefAttributes<HTMLButtonElement>>;
+interface NestedMenuProps {
+    parentOpen: boolean;
+    option: MenuOption;
+    disableAutoFocus?: boolean;
+    dismissEnabled?: boolean;
+}
+export declare function NestedMenu({ parentOpen, option, disableAutoFocus, dismissEnabled }: NestedMenuProps): import("react/jsx-runtime").JSX.Element;
+export default Menu;

package/dist/types/Menu/factory.d.ts

@@ -0,0 +1,6 @@
+import { PopoverPortalElProp } from '../popover/types.js';
+import { type MenuProps } from './controlled.js';
+export type MenuFactoryOptions = {
+    portalEl?: PopoverPortalElProp;
+};
+export declare function createMenuComponent({ portalEl }: MenuFactoryOptions): (props: MenuProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/Menu/index.d.ts

@@ -0,0 +1,3 @@
+export * from './controlled.js';
+export { default } from './controlled.js';
+export * from './factory.js';

package/dist/types/Pagination/index.d.ts

@@ -0,0 +1,7 @@
+export type PaginationProps = {
+    numPages: number;
+    page: number;
+    onChangePage(page: number): void;
+    className?: string;
+};
+export default function Pagination(props: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/RadioButton/index.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export type RadioButtonProps = Omit<React.ComponentPropsWithoutRef<'input'>, 'type'> & {
+    defaultChecked?: boolean;
+    checked?: boolean;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    'data-testid'?: string;
+    style?: React.CSSProperties;
+    className?: string;
+};
+declare const RadioButton: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "type"> & {
+    defaultChecked?: boolean | undefined;
+    checked?: boolean | undefined;
+    label?: React.ReactNode;
+    disabled?: boolean | undefined;
+    'data-testid'?: string | undefined;
+    style?: React.CSSProperties | undefined;
+    className?: string | undefined;
+} & React.RefAttributes<HTMLInputElement>>;
+export default RadioButton;

package/dist/types/Select/controlled.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { CommonSelectProps, SelectMultiValue, SelectSingleValue } from './types.js';
+export type ControlledSelectProps<OptionValue, Multiple extends boolean | undefined> = CommonSelectProps<OptionValue> & {
+    value: Multiple extends true ? SelectMultiValue<OptionValue> : SelectSingleValue<OptionValue>;
+    inputValue: string;
+    /**
+     * If `true`, `value` must be an array and the menu will support multiple selections.
+     * @default false
+     */
+    multiple: Multiple;
+    onChange(event: React.SyntheticEvent<HTMLElement>, newValue: Multiple extends true ? SelectMultiValue<OptionValue> : SelectSingleValue<OptionValue>): void;
+    onBlur?(): void;
+    onInputChange(event: React.SyntheticEvent<HTMLElement>, newValue: string): void;
+    'data-pendo'?: string;
+    tight?: boolean;
+};
+declare function ControlledSelect<OptionValue, Multiple extends boolean | undefined>({ ref, value, freeSolo, triggerChangeOnBlur, multiple, endIcon, placeholder, clearable, tight, ...props }: ControlledSelectProps<OptionValue, Multiple>): import("react/jsx-runtime").JSX.Element;
+export default ControlledSelect;

package/dist/types/Select/factory.d.ts

@@ -0,0 +1,11 @@
+import { PopoverPortalElProp } from '../popover/types.js';
+import Select from './uncontrolled.js';
+import ControlledSelect from './controlled.js';
+export type SelectFactoryOptions = {
+    portalEl?: PopoverPortalElProp;
+};
+export declare function createSelectComponent({ portalEl }: SelectFactoryOptions): typeof Select;
+export type ControlledSelectFactoryOptions = {
+    portalEl?: PopoverPortalElProp;
+};
+export declare function createControlledSelectComponent({ portalEl }: ControlledSelectFactoryOptions): typeof ControlledSelect;

package/dist/types/Select/index.d.ts

@@ -0,0 +1,5 @@
+export * from './controlled.js';
+export { default as ControlledSelect } from './controlled.js';
+export * from './uncontrolled.js';
+export { default } from './uncontrolled.js';
+export * from './factory.js';

package/dist/types/Select/types.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { PopoverStrategy, PopoverPortalElProp } from '../popover/index.js';
+export type SelectOption<OptionValue> = {
+    value: OptionValue;
+    label: string;
+    icon?: React.ReactElement;
+};
+export type SelectOptions<OptionValue> = SelectOption<OptionValue>[];
+export type SelectSingleValue<Value> = Value | null;
+export type SelectMultiValue<Value> = Value[] | null;
+export type MenuVirtualizeOptions = {
+    itemSize?: number;
+    overscan?: number;
+    maxHeight?: number;
+};
+export type CommonSelectProps<OptionValue> = {
+    ref?: React.Ref<HTMLInputElement>;
+    placeholder?: string | undefined;
+    disabled?: boolean;
+    error?: boolean;
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+    clearable?: boolean;
+    size?: number;
+    /**
+     * If true, the Select is free solo, meaning that the user input is not bound to provided options.
+     */
+    freeSolo?: boolean;
+    triggerChangeOnBlur?: boolean;
+    pattern?: string;
+    multiple?: boolean;
+    options: SelectOptions<OptionValue>;
+    filterOptions?: (options: SelectOptions<OptionValue>) => SelectOptions<OptionValue>;
+    virtualize?: boolean | MenuVirtualizeOptions;
+    onMenuReachEnd?: () => void;
+    menuReachEndOffset?: number;
+    portalEl?: PopoverPortalElProp;
+    dropdownStrategy?: PopoverStrategy;
+    'data-testid'?: string;
+    style?: React.CSSProperties;
+    className?: string;
+};

package/dist/types/Select/uncontrolled.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { CommonSelectProps, SelectMultiValue, SelectSingleValue } from './types.js';
+export type { SelectOption, SelectOptions, SelectSingleValue } from './types.js';
+export type SelectProps<OptionValue, Multiple extends boolean | undefined> = CommonSelectProps<OptionValue> & {
+    defaultValue?: Multiple extends true ? SelectMultiValue<OptionValue> : SelectSingleValue<OptionValue>;
+    value?: Multiple extends true ? SelectMultiValue<OptionValue> : SelectSingleValue<OptionValue>;
+    inputValue?: string;
+    onChange?(event: React.SyntheticEvent<HTMLElement>, newValue: Multiple extends true ? SelectMultiValue<OptionValue> : SelectSingleValue<OptionValue>): void;
+    onBlur?(): void;
+    onInputChange?(event: React.SyntheticEvent<HTMLElement>, newValue: string, tight?: boolean): void;
+    tight?: boolean;
+};
+declare function Select<OptionValue, Multiple extends boolean | undefined>({ ref, defaultValue, value: propsValue, inputValue: propsInputValue, onChange: propsOnChange, onInputChange: propsOnInputChange, tight, ...props }: SelectProps<OptionValue, Multiple>): import("react/jsx-runtime").JSX.Element;
+export default Select;

package/dist/types/StatusChip/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { PaletteActionVariantsColors } from '../styles/index.js';
+export type StatusChipPalette = PaletteActionVariantsColors;
+export type StatusChipProps = {
+    children: React.ReactNode;
+    palette?: StatusChipPalette;
+    'data-testid'?: string;
+    className?: string;
+    style?: React.CSSProperties;
+};
+declare const StatusChip: ({ children, palette: palette, ...props }: StatusChipProps) => import("react/jsx-runtime").JSX.Element;
+export default StatusChip;

package/dist/types/Stepper/auto.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type Step } from './stepper.js';
+export type AutoStep = Step & {
+    validateStep?: () => boolean;
+    step: React.ReactNode;
+};
+export type AutoStepperProps = {
+    steps: AutoStep[];
+    onCancel: () => void;
+    onFinish: () => void;
+    backLabel?: string;
+    cancelLabel?: string;
+    nextLabel?: string;
+    finishLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+};
+export default function AutoStepper({ steps, onCancel, onFinish, backLabel, cancelLabel, nextLabel, finishLabel }: AutoStepperProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/Stepper/index.d.ts

@@ -0,0 +1,4 @@
+export * from './stepper.js';
+export { default as default } from './stepper.js';
+export * from './auto.js';
+export { default as AutoStepper } from './auto.js';

package/dist/types/Stepper/stepper.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type Step = {
+    label: React.ReactNode;
+    disabled?: boolean;
+};
+type StepperProps = {
+    steps: Step[];
+    activeStep: number;
+    onChangeStep(activeStep: number): void;
+    style?: React.CSSProperties;
+    className?: string;
+};
+declare const Stepper: ({ steps, activeStep, onChangeStep, style, className }: StepperProps) => import("react/jsx-runtime").JSX.Element;
+export default Stepper;

package/dist/types/Table/AutoTable/common.d.ts

@@ -0,0 +1,31 @@
+import { ColumnDef as RTColumnDef, PaginationState, Row, RowSelectionState, SortingState, RowData } from '@tanstack/react-table';
+import type { ColumnDef, ColumnHelper } from './types.js';
+import React from 'react';
+export declare function createColumnHelper<TData extends RowData, TMeta = unknown>(): ColumnHelper<TData, TMeta>;
+export type AutoTableHookOptions<TData, TMeta = unknown> = {
+    data: TData[] | ReadonlyArray<TData>;
+    columns: ColumnDef<TData, TMeta>[];
+    meta?: TMeta;
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
+    sorting: SortingState;
+    enableSorting: boolean;
+    onSortingChange(newSorting: SortingState): void;
+    manualSorting?: boolean;
+    rowSelection: RowSelectionState;
+    enableRowSelection: boolean;
+    onRowSelectionChange(newRowSelection: RowSelectionState): void;
+    pagination: PaginationState;
+    enablePagination: boolean;
+    onPageChange(newPage: number): void;
+    onRowsPerPageChange(newRowsPerPage: number): void;
+    manualPagination?: boolean;
+    manualRowCount?: number;
+};
+export declare function useAutoTable<TData, TMeta = unknown>(options: AutoTableHookOptions<TData, TMeta>): import("@tanstack/react-table").Table<TData>;
+export declare function mapColumnDefs<TData, TMeta>(columnDefs: ColumnDef<TData, TMeta>[]): RTColumnDef<TData>[];
+export declare function mapColumnDef<TData, TMeta, VData = unknown>(columnDef: ColumnDef<TData, TMeta, VData>): RTColumnDef<TData, VData>;
+export type ErrorContainerProps = {
+    error: boolean | string;
+};
+export type ErrorContainer = React.ComponentType<ErrorContainerProps>;
+export declare const DefaultErrorContainer: ErrorContainer;

package/dist/types/Table/AutoTable/controlled.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { AutoTableHookOptions, type ErrorContainer as ErrorContainerType } from './common.js';
+export type ControlledAutoTableProps<TData, TMeta = unknown> = AutoTableHookOptions<TData, TMeta> & {
+    stickyHeader?: boolean | {
+        offset: number;
+    };
+    loading?: boolean;
+    zeroStateMessage?: React.ReactNode;
+    error?: boolean | string;
+    ErrorContainer?: ErrorContainerType;
+    style?: React.CSSProperties;
+    className?: string;
+};
+export default function ControlledAutoTable<TData, TMeta = unknown>({ stickyHeader, loading, zeroStateMessage, error, ErrorContainer, style, className, ...options }: ControlledAutoTableProps<TData, TMeta>): import("react/jsx-runtime").JSX.Element;

package/dist/types/Table/AutoTable/index.d.ts

@@ -0,0 +1,46 @@
+import { SortingState, RowSelectionState, Row } from '@tanstack/react-table';
+import React, { type CSSProperties } from 'react';
+import type { ColumnDef } from './types.js';
+import { type ErrorContainer as ErrorContainerType } from './common.js';
+export { createColumnHelper } from './common.js';
+export type AutoTableProps<TData, TMeta = unknown> = {
+    data: TData[] | ReadonlyArray<TData>;
+    columns: ColumnDef<TData, TMeta>[];
+    meta?: TMeta;
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
+    /** controlled sorting */
+    sorting?: SortingState;
+    /** uncontrolled sorting */
+    defaultSorting?: SortingState;
+    enableSorting?: boolean;
+    onSortingChange?(newSorting: SortingState): void;
+    manualSorting?: boolean;
+    rowSelection?: RowSelectionState;
+    enableRowSelection?: boolean;
+    onRowSelectionChange?(newRowSelection: RowSelectionState): void;
+    page?: number;
+    rowsPerPage?: number;
+    enablePagination?: boolean;
+    onPageChange?(newPage: number): void;
+    onRowsPerPageChange?(newRowsPerPage: number): void;
+    manualRowCount?: number;
+    virtualizer?: {
+        scrollOffset?: number;
+        getScrollElement: () => Element | null;
+        renderWhenNotVisible?: boolean;
+        rowSize: number;
+        headerSize?: number;
+        overscan?: number;
+    };
+    stickyHeader?: boolean | {
+        offset: number;
+    };
+    loading?: boolean;
+    zeroStateMessage?: React.ReactNode;
+    error?: boolean | string;
+    ErrorContainer?: ErrorContainerType;
+    style?: CSSProperties;
+    className?: string;
+};
+declare function AutoTable<TData, TMeta = unknown>(props: AutoTableProps<TData, TMeta>): import("react/jsx-runtime").JSX.Element;
+export default AutoTable;

package/dist/types/Table/AutoTable/types.d.ts

@@ -0,0 +1,106 @@
+export { type SortingState } from '@tanstack/react-table';
+import { AccessorFn, Cell, Column, ColumnDefTemplate, ColumnMeta, DeepKeys, DeepValue, Getter, Header, Row, RowData, SortingFnOption, Table } from '@tanstack/react-table';
+export type InternalColumnMeta = {
+    noVerticalPadding?: boolean;
+};
+export type ColumnHelper<TData extends RowData, TMeta> = {
+    accessor: <TAccessor extends AccessorFn<TData> | DeepKeys<TData>, TValue extends TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never>(accessor: TAccessor, column: TAccessor extends AccessorFn<TData> ? DisplayColumnDef<TData, TMeta, TValue> : IdentifiedColumnDef<TData, TMeta, TValue>) => AccessorColumnDef<TData, TMeta, TValue>;
+    display: (column: DisplayColumnDef<TData, TMeta>) => ColumnDef<TData, TMeta, unknown>;
+};
+export interface HeaderContext<TData, TMeta, TValue> {
+    /**
+     * An instance of a column.
+     */
+    column: Column<TData, TValue>;
+    /**
+     * An instance of a header.
+     */
+    header: Header<TData, TValue>;
+    /**
+     * The table instance.
+     */
+    table: Table<TData>;
+    meta: TMeta;
+}
+export type StringOrTemplateHeader<TData, TMeta, TValue> = string | ColumnDefTemplate<HeaderContext<TData, TMeta, TValue>>;
+interface StringHeaderIdentifier {
+    header: string;
+    id?: string;
+}
+interface IdIdentifier<TData extends RowData, TMeta, TValue> {
+    id: string;
+    header?: StringOrTemplateHeader<TData, TMeta, TValue>;
+}
+type ColumnIdentifiers<TData extends RowData, TMeta, TValue> = IdIdentifier<TData, TMeta, TValue> | StringHeaderIdentifier;
+export interface IdentifiedColumnDef<TData extends RowData, TMeta = unknown, TValue = unknown> extends ColumnDefBase<TData, TMeta, TValue> {
+    id?: string;
+    header?: StringOrTemplateHeader<TData, TMeta, TValue>;
+}
+export interface CellContext<TData extends RowData, TMeta, TValue> {
+    cell: Cell<TData, TValue>;
+    column: Column<TData, TValue>;
+    getValue: Getter<TValue>;
+    renderValue: Getter<TValue | null>;
+    row: Row<TData>;
+    table: Table<TData>;
+    meta: TMeta;
+}
+export interface ColumnDefBase<TData extends RowData, TMeta = unknown, TValue = unknown> {
+    getUniqueValues?: AccessorFn<TData, unknown[]>;
+    meta?: ColumnMeta<TData, TValue>;
+    cell?: ColumnDefTemplate<CellContext<TData, TMeta, TValue>>;
+    noVerticalPadding?: boolean;
+    /**
+     * Enables/Disables multi-sorting for this column.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultisort)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableMultiSort?: boolean;
+    /**
+     * Enables/Disables sorting for this column.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    enableSorting?: boolean;
+    /**
+     * Inverts the order of the sorting for this column. This is useful for values that have an inverted best/worst scale where lower numbers are better, eg. a ranking (1st, 2nd, 3rd) or golf-like scoring
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#invertsorting)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    invertSorting?: boolean;
+    /**
+     * Set to `true` for sorting toggles on this column to start in the descending direction.
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortdescfirst)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortDescFirst?: boolean;
+    /**
+     * The sorting function to use with this column.
+     * - A `string` referencing a built-in sorting function
+     * - A custom sorting function
+     * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortingfn)
+     * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortingFn?: SortingFnOption<TData>;
+    /**
+     * - `false`
+     *   - Undefined values will be considered tied and need to be sorted by the next column filter or original index (whichever applies)
+     * - `-1`
+     *   - Undefined values will be sorted with higher priority (ascending) (if ascending, undefined will appear on the beginning of the list)
+     * - `1`
+     *   - Undefined values will be sorted with lower priority (descending) (if ascending, undefined will appear on the end of the list)
+     */
+    sortUndefined?: false | -1 | 1;
+}
+export type DisplayColumnDef<TData extends RowData, TMeta = unknown, TValue = unknown> = ColumnDefBase<TData, TMeta, TValue> & ColumnIdentifiers<TData, TMeta, TValue>;
+interface AccessorFnColumnDefBase<TData extends RowData, TMeta, TValue = unknown> extends ColumnDefBase<TData, TMeta, TValue> {
+    accessorFn: AccessorFn<TData, TValue>;
+}
+export type AccessorFnColumnDef<TData extends RowData, TMeta = unknown, TValue = unknown> = AccessorFnColumnDefBase<TData, TMeta, TValue> & ColumnIdentifiers<TData, TMeta, TValue>;
+interface AccessorKeyColumnDefBase<TData extends RowData, TMeta, TValue = unknown> extends ColumnDefBase<TData, TMeta, TValue> {
+    id?: string;
+    accessorKey: (string & {}) | keyof TData;
+}
+export type AccessorKeyColumnDef<TData extends RowData, TMeta = unknown, TValue = unknown> = AccessorKeyColumnDefBase<TData, TMeta, TValue> & Partial<ColumnIdentifiers<TData, TMeta, TValue>>;
+export type AccessorColumnDef<TData extends RowData, TMeta, TValue = unknown> = AccessorKeyColumnDef<TData, TMeta, TValue> | AccessorFnColumnDef<TData, TMeta, TValue>;
+export type ColumnDef<TData extends RowData, TMeta = unknown, TValue = unknown> = DisplayColumnDef<TData, TMeta, TValue> | AccessorColumnDef<TData, TMeta, TValue>;

package/dist/types/Table/AutoTable/virtual.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { AutoTableHookOptions, type ErrorContainer as ErrorContainerType } from './common.js';
+export type VirtualControlledAutoTableProps<TData, TMeta = unknown> = AutoTableHookOptions<TData, TMeta> & {
+    stickyHeader?: boolean | {
+        offset: number;
+    };
+    loading?: boolean;
+    zeroStateMessage?: React.ReactNode;
+    error?: boolean | string;
+    ErrorContainer?: ErrorContainerType;
+    scrollOffset?: number;
+    getScrollElement: () => Element | null;
+    renderWhenNotVisible?: boolean;
+    rowSize: number;
+    headerSize?: number;
+    overscan?: number;
+    debug?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+};
+export declare const TableMessageMaxHeight = 100;
+export default function VirtualControlledAutoTable<TData, TMeta = unknown>({ stickyHeader, loading, zeroStateMessage, error, ErrorContainer, scrollOffset, getScrollElement, renderWhenNotVisible, rowSize, headerSize, overscan, debug, style, className, ...options }: VirtualControlledAutoTableProps<TData, TMeta>): import("react/jsx-runtime").JSX.Element;

package/dist/types/Table/TableCell/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type TableCellProps = React.ComponentPropsWithoutRef<'td'> & {
+    'data-testid'?: string | undefined;
+    children?: React.ReactNode;
+    noVerticalPadding?: boolean;
+    variant?: 'header' | 'data';
+};
+declare const TableCell: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref"> & {
+    'data-testid'?: string | undefined;
+    children?: React.ReactNode;
+    noVerticalPadding?: boolean | undefined;
+    variant?: "data" | "header" | undefined;
+} & React.RefAttributes<HTMLTableCellElement>>;
+export default TableCell;

package/dist/types/Table/TableRow/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export type TableRowProps = React.ComponentPropsWithoutRef<'tr'> & {
+    'data-testid'?: string | undefined;
+    children?: React.ReactNode;
+};
+declare const TableRow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & {
+    'data-testid'?: string | undefined;
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLTableRowElement>>;
+export default TableRow;

package/dist/types/Table/index.d.ts

@@ -0,0 +1,67 @@
+import React, { type CSSProperties, MouseEventHandler } from 'react';
+export type TableProps = {
+    'data-testid'?: string;
+    /**
+     * Set the header sticky.
+     *
+     * ⚠️ It doesn't work with IE11.
+     * @default false
+     */
+    stickyHeader?: boolean;
+    children?: React.ReactNode;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const Table: (props: TableProps) => import("react/jsx-runtime").JSX.Element;
+export type TableBodyProps = {
+    'data-testid'?: string;
+    children?: React.ReactNode;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const TableBody: (props: TableBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type TableFooterProps = {
+    'data-testid'?: string;
+    children?: React.ReactNode;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const TableFooter: (props: TableFooterProps) => import("react/jsx-runtime").JSX.Element;
+export type TableHeadProps = {
+    'data-testid'?: string;
+    children?: React.ReactNode;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const TableHead: (props: TableHeadProps) => import("react/jsx-runtime").JSX.Element;
+export type TableSortLabelProps = {
+    'data-testid'?: string;
+    /**
+     * If `true`, the label will have the active styling (should be true for the sorted column).
+     * @default false
+     */
+    active?: boolean;
+    /**
+     * Label contents, the arrow will be appended automatically.
+     */
+    children?: React.ReactNode;
+    /**
+     * The current sort direction.
+     * @default 'asc'
+     */
+    direction?: 'asc' | 'desc';
+    /**
+     * Hide sort icon when active is false.
+     * @default false
+     */
+    hideSortIcon?: boolean;
+    disabled?: boolean;
+    onClick?: MouseEventHandler<HTMLSpanElement>;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const TableSortLabel: (props: TableSortLabelProps) => import("react/jsx-runtime").JSX.Element;
+export type TableZeroStateProps = {
+    children: React.ReactNode;
+};
+export declare const TableMessage: (props: TableZeroStateProps) => import("react/jsx-runtime").JSX.Element;