@toolpath/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1174 @@
+import * as react from 'react';
+import react__default, { HTMLAttributes, ReactNode, ReactElement, Dispatch, MouseEvent, Ref, FC, SVGProps, RefAttributes, ButtonHTMLAttributes, InputHTMLAttributes, ComponentType, AnchorHTMLAttributes, SetStateAction, TextareaHTMLAttributes, RefObject } from 'react';
+import { CheckboxRootProps, ComboboxRootProps, ComboboxGroupProps as ComboboxGroupProps$1, ComboboxGroupLabelProps as ComboboxGroupLabelProps$1, ComboboxIconProps as ComboboxIconProps$1, ComboboxInputProps as ComboboxInputProps$1, ComboboxItemProps as ComboboxItemProps$1, ComboboxItemIndicatorProps as ComboboxItemIndicatorProps$1, ComboboxListProps as ComboboxListProps$1, ComboboxPopupProps, ComboboxPositionerProps, ComboboxTriggerProps as ComboboxTriggerProps$1, ComboboxValueProps as ComboboxValueProps$1, SeparatorProps, MenuItemProps as MenuItemProps$1, MenuRoot, ContextMenu, MenuPopupProps, MenuPositionerProps, MenuSubmenuRootProps as MenuSubmenuRootProps$1, MenuSubmenuTriggerProps as MenuSubmenuTriggerProps$1, MenuTriggerProps as MenuTriggerProps$1, ContextMenuTriggerProps, ToastProviderProps as ToastProviderProps$1, UseToastManagerReturnValue, SwitchRootProps, TooltipProviderProps, TooltipRootProps, TooltipPositionerProps } from '@base-ui/react';
+import { SliderRootProps, SliderThumbProps, SliderRoot } from '@base-ui/react/slider';
+import { CellProps as CellProps$1, HeaderRowProps as HeaderRowProps$1, RowProps, TableNode as TableNode$1, Identifier } from '@table-library/react-table-library/types/table';
+import { TableNode } from '@table-library/react-table-library/table';
+import { HeaderCellSortProps } from '@table-library/react-table-library/types/sort';
+import { IdState } from '@table-library/react-table-library/types/common';
+import { VirtualizedProps } from '@table-library/react-table-library/types/virtualized';
+import { GroupProps, PanelSize, PanelImperativeHandle, SeparatorProps as SeparatorProps$1, isCoarsePointer, useDefaultLayout, useGroupCallbackRef, useGroupRef, usePanelCallbackRef, usePanelRef, GroupImperativeHandle, Layout, LayoutStorage, OnGroupLayoutChange, OnPanelResize, Orientation, PanelProps, SizeUnit } from 'react-resizable-panels';
+
+type AttributionActionProps = HTMLAttributes<HTMLSpanElement> & {
+    children?: ReactNode;
+};
+declare const Action: ({ className, children, ...props }: AttributionActionProps) => react__default.JSX.Element;
+
+type AttributionAtProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & {
+    date: string | Date;
+    hideTime?: boolean;
+};
+declare const At: ({ date, hideTime, className, ...props }: AttributionAtProps) => react__default.JSX.Element;
+
+type AttributionProps = HTMLAttributes<HTMLDivElement>;
+
+type AttributionByProps = HTMLAttributes<HTMLSpanElement> & {
+    children?: ReactNode;
+};
+declare const By: ({ className, children, ...props }: AttributionByProps) => react__default.JSX.Element;
+
+type AttributionCompoundType = {
+    (props: AttributionProps): ReactElement;
+    Action: typeof Action;
+    At: typeof At;
+    By: typeof By;
+};
+declare const Attribution: AttributionCompoundType;
+
+type ButtonProps = HTMLAttributes<HTMLButtonElement | HTMLAnchorElement> & {
+    children: ReactNode;
+    variant?: 'default' | 'primary' | 'secondary' | 'info' | 'muted' | 'danger' | 'success';
+    size?: 'sm' | 'md' | 'lg';
+    shape?: 'default' | 'pill';
+    disabled?: boolean;
+    isLoading?: boolean;
+    onClick?: Dispatch<MouseEvent>;
+    type?: 'button' | 'submit' | 'reset';
+    className?: string;
+    asLink?: boolean;
+    href?: string;
+    form?: string;
+    target?: string;
+    full?: boolean;
+    ref?: Ref<HTMLButtonElement | HTMLAnchorElement>;
+};
+declare const Button$1: ({ variant, size, shape, type, className, isLoading, children, onClick, asLink, href, form, full, disabled, ref, ...props }: ButtonProps) => react__default.JSX.Element;
+
+type CalloutProps = {
+    id: string;
+    children: ReactNode;
+    show?: boolean;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+    highlight?: boolean;
+    /** When false, dismiss state is local only and not persisted to localStorage. Defaults to true. */
+    rememberDismissed?: boolean;
+};
+declare const Callout: {
+    ({ id, children, show, highlight, side, sideOffset, align, rememberDismissed, }: CalloutProps): react__default.JSX.Element;
+    Trigger: ({ children, className, tabIndex }: CalloutTriggerProps) => react__default.JSX.Element;
+    Content: ({ children, className }: CalloutContentProps) => react__default.JSX.Element;
+};
+type CalloutTriggerProps = {
+    children: ReactNode;
+    className?: string;
+    /** Set to -1 to remove the trigger from the tab order and suppress focus styling. */
+    tabIndex?: number;
+};
+type CalloutContentProps = {
+    children: ReactNode;
+    className?: string;
+};
+
+declare const useDismissedCallouts: () => {
+    isDismissed: (id: string) => boolean;
+    dismiss: (id: string) => void;
+    reset: (id?: string) => void;
+};
+
+interface CheckboxChangeEvent {
+    shiftKey: boolean;
+}
+type CheckboxProps = CheckboxRootProps & {
+    checked: boolean;
+    onChange: (checked: boolean, event: CheckboxChangeEvent) => void;
+    name: string;
+    className?: string;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    tabIndex?: number;
+    variant?: 'default' | 'muted';
+    size?: 'md' | 'sm';
+};
+declare const Checkbox: ({ checked, onChange, name, className, disabled, indeterminate, variant, size, ...props }: CheckboxProps) => react__default.JSX.Element;
+
+type ComboboxButtonProps = {
+    placeholder?: string;
+    icon?: FC<SVGProps<SVGSVGElement>>;
+    children?: ReactNode;
+};
+declare const Button: ({ placeholder, icon: IconComponent, children, }: ComboboxButtonProps) => react__default.JSX.Element;
+
+type ComboboxProps<T> = ComboboxRootProps<T> & {
+    size?: 'xl' | 'lg' | 'md' | 'sm';
+    variant?: 'default' | 'secondary' | 'muted' | 'ghost';
+    invalid?: boolean;
+};
+
+interface ComboboxContextInterface {
+    size: 'xl' | 'lg' | 'md' | 'sm';
+    variant: 'default' | 'secondary' | 'muted' | 'ghost';
+    disabled: boolean;
+    invalid: boolean;
+    itemToStringLabel?: (item: any) => string;
+}
+declare const useCombobox: () => Partial<ComboboxContextInterface>;
+
+type ComboboxEmptyProps = HTMLAttributes<HTMLDivElement> & {
+    children?: ReactNode;
+};
+declare const Empty: ({ className, children, ...props }: ComboboxEmptyProps) => react__default.JSX.Element;
+
+type ComboboxGroupProps = ComboboxGroupProps$1;
+declare const Group: ({ children, ...props }: ComboboxGroupProps) => react__default.JSX.Element;
+
+type ComboboxGroupLabelProps = ComboboxGroupLabelProps$1;
+declare const GroupLabel: ({ className, children, ...props }: ComboboxGroupLabelProps) => react__default.JSX.Element;
+
+type ComboboxIconProps = ComboboxIconProps$1 & RefAttributes<HTMLDivElement>;
+declare const Icon: ({ children, ...props }: ComboboxIconProps) => react__default.JSX.Element;
+
+type ComboboxInputProps = ComboboxInputProps$1;
+declare const Input$1: ({ className, ...props }: ComboboxInputProps) => react__default.JSX.Element;
+
+type ComboboxItemProps = ComboboxItemProps$1;
+declare const Item$3: ({ className, children, value, ...props }: ComboboxItemProps) => react__default.JSX.Element;
+
+type ComboboxItemIndicatorProps = Omit<HTMLAttributes<HTMLSpanElement>, 'children'> & ComboboxItemIndicatorProps$1;
+declare const ItemIndicator: ({ children, ...props }: ComboboxItemIndicatorProps) => react__default.JSX.Element;
+
+type ComboboxListProps = ComboboxListProps$1;
+declare const List$3: ({ className, children, ...props }: ComboboxListProps) => react__default.JSX.Element;
+
+type ComboboxPopoverProps = ComboboxPopupProps & Omit<ComboboxPositionerProps, 'children'>;
+declare const Popover$1: ({ className, anchor, positionMethod, side, sideOffset, align, alignOffset, collisionBoundary, collisionPadding, sticky, arrowPadding, disableAnchorTracking, collisionAvoidance, children, ...props }: ComboboxPopoverProps) => react__default.JSX.Element;
+
+type ComboboxTriggerProps = ComboboxTriggerProps$1 & RefAttributes<HTMLElement>;
+declare const Trigger$1: ({ className, children, nativeButton, render, ...props }: ComboboxTriggerProps) => react__default.JSX.Element;
+
+type ComboboxValueProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & ComboboxValueProps$1;
+declare const Value: ({ children, ...props }: ComboboxValueProps) => react__default.JSX.Element;
+
+type ComboboxCompoundType = {
+    <T>(props: ComboboxProps<T>): ReactElement;
+    Empty: typeof Empty;
+    Group: typeof Group;
+    GroupLabel: typeof GroupLabel;
+    Input: typeof Input$1;
+    Item: typeof Item$3;
+    ItemIndicator: typeof ItemIndicator;
+    List: typeof List$3;
+    Popover: typeof Popover$1;
+    Trigger: typeof Trigger$1;
+    Button: typeof Button;
+    Value: typeof Value;
+    Icon: typeof Icon;
+    useCombobox: typeof useCombobox;
+};
+declare const Combobox: ComboboxCompoundType;
+
+interface DialogActionsProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const Actions: ({ children, className, ...props }: DialogActionsProps) => react__default.JSX.Element;
+
+interface DialogConfirmProps extends Omit<ButtonProps, 'onClick'> {
+    children: ReactNode;
+}
+declare const Confirm: ({ children, className, variant, ...props }: DialogConfirmProps) => react__default.JSX.Element;
+
+interface DialogDismissProps extends Omit<ButtonProps, 'onClick'> {
+    children: ReactNode;
+}
+declare const Dismiss: ({ children, className, variant, ...props }: DialogDismissProps) => react__default.JSX.Element;
+
+interface DialogMessageProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const Message: ({ children, className, ...props }: DialogMessageProps) => react__default.JSX.Element;
+
+interface ProviderContextValue {
+    confirm: (dialog: ReactElement) => Promise<boolean>;
+}
+interface DialogProviderProps {
+    children: ReactNode;
+}
+declare const Provider$2: ({ children }: DialogProviderProps) => react__default.JSX.Element;
+declare const useDialog: () => ProviderContextValue;
+
+type DialogVariant = 'danger' | 'success';
+
+interface DialogRootProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    variant: DialogVariant;
+}
+declare const Dialog$1: ({ children, variant, className, ...props }: DialogRootProps) => react__default.JSX.Element;
+
+interface DialogTitleProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare const Title: ({ children, className, ...props }: DialogTitleProps) => react__default.JSX.Element;
+
+type DialogCompoundType = typeof Dialog$1 & {
+    Provider: typeof Provider$2;
+    Title: typeof Title;
+    Message: typeof Message;
+    Actions: typeof Actions;
+    Confirm: typeof Confirm;
+    Dismiss: typeof Dismiss;
+    useDialog: typeof useDialog;
+};
+declare const Dialog: DialogCompoundType;
+
+interface EditingCell$1 {
+    rowId: string | number;
+    field: string;
+}
+type NavigateDirection = 'next' | 'prev' | 'up' | 'down';
+interface EditableCellProps {
+    rowId: string | number;
+    field: string;
+    value: number | string | null | undefined;
+    type?: 'text' | 'number';
+    editingCell: EditingCell$1 | null;
+    additionalCells?: Array<EditingCell$1>;
+    modifierHeld?: boolean;
+    onStartEdit?: (rowId: string | number, field: string) => void;
+    onToggleAdditional?: (rowId: string | number, field: string) => void;
+    onSelectThrough?: (rowId: string | number, field: string) => void;
+    onExtendSelection?: (direction: 'up' | 'down') => void;
+    onCommit: (rowId: string | number, field: string, rawValue: string, dirty?: boolean) => void;
+    onNavigate?: (rowId: string | number, field: string, rawValue: string, direction: NavigateDirection, dirty?: boolean) => void;
+    onCancel: () => void;
+    children: ReactNode;
+}
+declare const EditableCell: FC<EditableCellProps>;
+
+interface EditableGridOptions<T> {
+    data: Array<T>;
+    fields: ReadonlyArray<string>;
+    getId: (item: T) => string | number;
+    isFieldEditable?: (item: T, field: string) => boolean;
+    onCommit: (rowId: string | number, field: string, rawValue: string) => void;
+    onBatchCommit?: (cells: Array<{
+        rowId: string | number;
+        field: string;
+    }>, rawValue: string) => void;
+}
+declare const useEditableGrid: <T>({ data, fields, getId, isFieldEditable, onCommit, onBatchCommit, }: EditableGridOptions<T>) => {
+    editingCell: EditingCell$1;
+    additionalCells: EditingCell$1[];
+    modifierHeld: boolean;
+    handleStartEdit: (rowId: string | number, field: string) => void;
+    handleSelectColumn: (field: string) => void;
+    handleToggleAdditional: (rowId: string | number, field: string) => void;
+    handleSelectThrough: (rowId: string | number, field: string) => void;
+    handleExtendSelection: (direction: "up" | "down") => void;
+    handleCommit: (rowId: string | number, field: string, rawValue: string, dirty?: boolean) => void;
+    handleCancel: () => void;
+    handleNavigate: (rowId: string | number, field: string, rawValue: string, direction: NavigateDirection, dirty?: boolean) => void;
+};
+
+type BadgeProps = {
+    children: ReactNode;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'default' | 'secondary' | 'success' | 'primary' | 'info' | 'danger';
+    className?: string;
+};
+declare const Badge: ({ children, size, variant, className }: BadgeProps) => react__default.JSX.Element;
+
+type Breakpoint = 'sm' | 'md' | 'lg' | 'xl';
+type BreadcrumbsProps = {
+    children: ReactNode;
+    breakpoint?: Breakpoint;
+    className?: string;
+};
+
+type BreadcrumbsItemProps = {
+    to: string;
+    children: ReactNode;
+    current?: boolean;
+    previous?: boolean;
+    className?: string;
+};
+declare const Item$2: ({ to, children, current, previous, className, }: BreadcrumbsItemProps) => react__default.JSX.Element;
+
+type BreadcrumbsCompoundType = {
+    (props: BreadcrumbsProps): ReactElement;
+    Item: typeof Item$2;
+};
+declare const Breadcrumbs: BreadcrumbsCompoundType;
+
+interface CardProps {
+    children: ReactNode;
+    className?: string;
+}
+/** A standard Toolpath application surface. */
+declare const Card: ({ children, className }: CardProps) => react.JSX.Element;
+
+interface FieldProps {
+    title: string;
+    description?: string;
+    content?: ReactNode;
+    children?: ReactNode;
+}
+/** A labelled settings row with an optional right-aligned control. */
+declare const Field: ({ title, description, content, children }: FieldProps) => react.JSX.Element;
+
+type IconButtonSize = 'sm' | 'md' | 'lg' | 'xl';
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'default' | 'muted' | 'secondary';
+    size?: IconButtonSize;
+    children: ReactNode;
+    toggled?: boolean;
+    invalid?: boolean;
+    deemphasize?: boolean;
+    ref?: Ref<HTMLButtonElement>;
+}
+interface IconButtonIndicatorProps {
+    variant?: 'info' | 'success' | 'primary' | 'danger' | 'warning';
+    children?: ReactNode;
+}
+declare const IconButton: (({ variant, size, disabled, children, className, toggled, invalid, deemphasize, ref, ...props }: IconButtonProps) => react__default.JSX.Element) & {
+    Indicator: ({ variant, children }: IconButtonIndicatorProps) => react__default.JSX.Element;
+};
+
+type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix'> & {
+    name: string;
+    id: string;
+    size?: 'md' | 'lg' | 'xl';
+    variant?: 'default' | 'secondary' | 'muted' | 'ghost';
+    icon?: ComponentType<SVGProps<SVGSVGElement>>;
+    iconPosition?: 'left' | 'right';
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    textEnd?: boolean;
+    invalid?: boolean;
+    showSpinner?: boolean;
+    copyable?: boolean;
+    onCopyError?: () => void;
+    onValueChange?: (value: string | null) => void;
+    ref?: Ref<HTMLInputElement>;
+};
+declare const Input: ({ type, name, id, value, className, disabled, variant, icon: IconComponent, iconPosition, suffix, prefix, size, textEnd, invalid, showSpinner, copyable, onCopyError, onValueChange, ref, ...props }: InputProps) => react__default.JSX.Element;
+
+type LinkComponentProps = AnchorHTMLAttributes<HTMLAnchorElement> & {
+    ref?: Ref<HTMLAnchorElement>;
+};
+type LinkContextValue = {
+    LinkComponent: ComponentType<LinkComponentProps>;
+};
+declare const useLinkContext: () => LinkContextValue;
+type LinkProviderProps = {
+    children: ReactNode;
+    component: ComponentType<LinkComponentProps>;
+};
+declare const LinkProvider: ({ children, component }: LinkProviderProps) => react__default.JSX.Element;
+
+type LinkProps = LinkComponentProps & {
+    children: ReactNode;
+    className?: string;
+    ref?: Ref<HTMLAnchorElement>;
+};
+declare const Link: ({ children, className, ref, ...props }: LinkProps) => react__default.JSX.Element;
+
+type MenuDividerProps = SeparatorProps;
+declare const Divider: ({ className, ...props }: MenuDividerProps) => react__default.JSX.Element;
+
+type MenuItemProps = MenuItemProps$1 & {
+    variant?: 'default' | 'danger';
+    ref?: Ref<HTMLElement>;
+};
+declare const Item$1: ({ children, className, disabled, variant, ref, onClick, ...props }: MenuItemProps) => react__default.JSX.Element;
+
+type MenuProps = (MenuRoot.Props & {
+    context?: false;
+}) | (ContextMenu.Root.Props & {
+    context: true;
+});
+
+interface MenuContextInterface {
+    context: boolean;
+    submenu: boolean;
+}
+declare const useMenu: () => Partial<MenuContextInterface>;
+
+type MenuPopoverProps = MenuPopupProps & Omit<MenuPositionerProps, 'children'>;
+declare const Popover: ({ className, anchor, positionMethod, side, sideOffset, align, alignOffset, collisionBoundary, collisionPadding, sticky, arrowPadding, disableAnchorTracking, collisionAvoidance, children, ...props }: MenuPopoverProps) => react__default.JSX.Element;
+
+type MenuSubmenuRootProps = MenuSubmenuRootProps$1;
+declare const Submenu: ({ ...props }: MenuSubmenuRootProps) => react__default.JSX.Element;
+
+type MenuSubmenuTriggerProps = MenuSubmenuTriggerProps$1 & RefAttributes<HTMLElement>;
+declare const SubmenuTrigger: ({ className, children, ...props }: MenuSubmenuTriggerProps) => react__default.JSX.Element;
+
+type MenuTriggerProps = (MenuTriggerProps$1 & RefAttributes<HTMLElement>) | (ContextMenuTriggerProps & RefAttributes<HTMLDivElement>);
+declare const Trigger: ({ className, children, ...props }: MenuTriggerProps) => react__default.JSX.Element;
+
+type MenuCompoundType = {
+    (props: MenuProps): ReactElement;
+    Divider: typeof Divider;
+    Item: typeof Item$1;
+    Popover: typeof Popover;
+    SubmenuTrigger: typeof SubmenuTrigger;
+    Submenu: typeof Submenu;
+    Trigger: typeof Trigger;
+    useMenu: typeof useMenu;
+};
+declare const Menu: MenuCompoundType;
+
+type NotificationVariant = 'info' | 'warning' | 'danger' | 'success';
+declare const List$2: () => react__default.JSX.Element;
+
+type NotificationProviderProps = Omit<ToastProviderProps$1, 'children'> & {
+    children?: ReactNode;
+};
+declare const Provider$1: ({ children, ...props }: NotificationProviderProps) => react__default.JSX.Element;
+type NotificationManager = {
+    toasts: UseToastManagerReturnValue['toasts'];
+    add: <Data extends object>(options: Parameters<UseToastManagerReturnValue['add']>[0] & {
+        variant: NotificationVariant;
+    } & {
+        data?: Data;
+    }) => string;
+    close: UseToastManagerReturnValue['close'];
+    update: UseToastManagerReturnValue['update'];
+    promise: UseToastManagerReturnValue['promise'];
+};
+declare const useNotificationManager: () => NotificationManager;
+
+type NotificationCompoundType = {
+    List: typeof List$2;
+    Provider: typeof Provider$1;
+    useNotificationManager: typeof useNotificationManager;
+};
+declare const Notification: NotificationCompoundType;
+
+type QuantityInputProps = {
+    value: number;
+    onValueChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'default' | 'muted';
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    ref?: Ref<HTMLInputElement>;
+};
+declare const QuantityInput: ({ value, onValueChange, min, max, step, size, variant, disabled, className, id, ref, }: QuantityInputProps) => react__default.JSX.Element;
+
+type SliderProps = Omit<SliderRootProps, 'onValueChange'> & {
+    variant?: 'default';
+    onFocus?: SliderThumbProps['onFocus'] | undefined;
+    onBlur?: SliderThumbProps['onBlur'] | undefined;
+    onValueChange?: (value: number, eventDetails: SliderRoot.ChangeEventDetails) => void;
+};
+declare const Slider: ({ variant, onFocus, onBlur, onValueChange, className, ...props }: SliderProps) => react__default.JSX.Element;
+
+interface PinChangeEvent {
+    shiftKey: boolean;
+}
+type PinProps = {
+    checked: boolean;
+    onChange: (checked: boolean, event: PinChangeEvent) => void;
+    name: string;
+    className?: string;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    tabIndex?: number;
+};
+declare const Pin: ({ checked, onChange, name, className, disabled, size, tabIndex, }: PinProps) => react__default.JSX.Element;
+
+type ProgressBarSize = 'xs' | 'sm' | 'md' | 'lg';
+type ProgressBarProps = {
+    progress: number;
+    size?: ProgressBarSize;
+    className?: string;
+};
+declare const ProgressBar: ({ progress, size, className }: ProgressBarProps) => react__default.JSX.Element;
+
+interface StarChangeEvent {
+    shiftKey: boolean;
+}
+type StarProps = {
+    checked: boolean;
+    onChange: (checked: boolean, event: StarChangeEvent) => void;
+    name: string;
+    className?: string;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    tabIndex?: number;
+};
+declare const Star: ({ checked, onChange, name, className, disabled, size, tabIndex, }: StarProps) => react__default.JSX.Element;
+
+type SwitchProps = SwitchRootProps;
+declare const Switch: ({ checked, onCheckedChange, disabled, className, ...props }: SwitchProps) => react__default.JSX.Element;
+
+interface CellProps extends CellProps$1 {
+    divider?: boolean;
+    tree?: boolean;
+}
+declare const Cell: react__default.NamedExoticComponent<CellProps>;
+
+interface HeaderCellProps extends Omit<HeaderCellSortProps, 'sortKey'> {
+    sort?: boolean;
+    sortFn?: (array: Array<TableNode>) => Array<TableNode>;
+    width?: string | number;
+    sortKey?: string;
+    divider?: boolean;
+}
+interface HeaderCellInteractiveProps extends HTMLAttributes<HTMLSpanElement> {
+    children: ReactNode;
+}
+interface HeaderCellContentProps extends HTMLAttributes<HTMLSpanElement> {
+    accessory?: ReactNode;
+    children: ReactNode;
+}
+declare const HeaderCellContent: ({ accessory, children, className, style, ...props }: HeaderCellContentProps) => react__default.JSX.Element;
+declare const HeaderCellInteractive: ({ children, className, onClick, onMouseDown, style, ...props }: HeaderCellInteractiveProps) => react__default.JSX.Element;
+declare const HeaderCell: ({ children, sortKey, sortFn, resize, width: _width, divider, ...props }: HeaderCellProps) => react__default.JSX.Element;
+
+interface HeaderRowProps extends HeaderRowProps$1 {
+    noOffset?: boolean;
+    className?: string;
+}
+declare const HeaderRow: ({ children, noOffset, className, ...props }: HeaderRowProps) => react__default.JSX.Element;
+
+declare const Row: react__default.MemoExoticComponent<({ children, onClick, disabled, ...props }: Omit<RowProps<any>, "item"> & {
+    disabled?: boolean;
+}) => react__default.JSX.Element>;
+
+type EditingCell = [number, number | string, number];
+type TableDensity$1 = 'dense' | 'roomy';
+interface TableContextInterface {
+    columns: number;
+    density: TableDensity$1;
+    select: boolean;
+    multiselect: boolean;
+    keyboardNavigation: boolean;
+    isEmpty: boolean;
+    cursor: number | null;
+    setCursor: Dispatch<SetStateAction<number | null>>;
+    selectedRows: IdState;
+    setSelectedRows: Dispatch<SetStateAction<IdState>>;
+    editingCell: EditingCell | null;
+    setEditingCell: Dispatch<SetStateAction<EditingCell | null>>;
+    collapsedGroups: Array<number>;
+    setCollapsedGroups: Dispatch<SetStateAction<Array<number>>>;
+    /**
+     * Called before selection changes (on row click). Return false to cancel
+     * both cursor and selection updates. Useful for dirty state confirmation.
+     */
+    onBeforeSelectionChange?: (item: any, index: number | null) => boolean;
+}
+declare const useTable: () => TableContextInterface;
+
+interface RowContextInterface {
+    item: any;
+    index: number;
+    groupIndex?: number;
+    isSelected: boolean;
+    isOnlySelected: boolean;
+    isDirectlySelected: boolean;
+    isHovered: boolean;
+    setIsHovered: Dispatch<SetStateAction<boolean>>;
+}
+declare const useRow: () => RowContextInterface;
+
+interface CellContextInterface {
+    index: number;
+    isEditing: boolean;
+    toggleIsEditing: () => void;
+    isHovered: boolean;
+}
+declare const useCell: () => CellContextInterface;
+
+type UseCheckboxReturn = {
+    isChecked: (item: TableNode$1) => boolean;
+    isIndeterminate: (item: TableNode$1) => boolean;
+    handleCheck: (item: TableNode$1, checked: boolean, event?: CheckboxChangeEvent) => void;
+    checkedItems: Array<Identifier>;
+};
+declare const useCheckbox: (items: Array<TableNode$1>, initialState?: Array<Identifier>) => UseCheckboxReturn;
+
+interface TableEmptyProps {
+    header?: ReactElement;
+    emptyButtonLabel?: ReactNode;
+    emptyButtonText?: string;
+    onClickEmptyButton?: () => void;
+}
+declare const TableEmpty: ({ header, emptyButtonLabel, emptyButtonText, onClickEmptyButton, }: TableEmptyProps) => react__default.JSX.Element;
+
+type TableSelectedRows$1 = IdState | undefined;
+type TableSortDirection = 'asc' | 'desc';
+type TableSort = number | string | readonly [number | string, TableSortDirection];
+type TableSortState$1 = {
+    sortKey: number | null;
+    direction: TableSortDirection;
+    reverse: boolean;
+};
+interface TableProps<T> extends Omit<VirtualizedProps<any>, 'tableList' | 'rowHeight' | 'header' | 'body'> {
+    data: Array<T>;
+    id?: string;
+    density?: TableDensity$1;
+    header: ReactNode;
+    select?: boolean;
+    multiselect?: boolean;
+    empty?: ReactElement<TableEmptyProps>;
+    selectedRows?: any;
+    setSelectedRows?: Dispatch<SetStateAction<any>>;
+    editingCell?: EditingCell;
+    setEditingCell?: Dispatch<SetStateAction<EditingCell | null>>;
+    /**
+     * Initial sort (column index, header key, or tuple with direction).
+     * Accepts column index (number), header key (string), or
+     * [key, 'asc' | 'desc'].
+     */
+    defaultSort?: TableSort;
+    onSortChange?: (sortState: TableSortState$1) => void;
+    children: (node: T, index: number) => ReactNode;
+    className?: string;
+    grouped?: {
+        counts: Array<number>;
+        header: (index: number) => ReactNode;
+        emptyState?: (index: number) => ReactNode;
+    };
+    defaultCollapsedGroups?: Array<number>;
+    tree?: boolean;
+    /** Enable vertical scroll with hidden scrollbar. Parent must have explicit height. */
+    scrollable?: boolean;
+    /** Render every row instead of using virtualized rows. */
+    virtualized?: boolean;
+    /** Disable the built-in keyboard navigation (arrow keys, escape). Default true. */
+    keyboardNavigation?: boolean;
+    /**
+     * Called before selection changes (on row click). Return false to cancel
+     * both cursor and selection updates. Useful for dirty state confirmation.
+     */
+    onBeforeSelectionChange?: (item: T, index: number | null) => boolean;
+}
+
+type TableSelectedRows = TableSelectedRows$1 | undefined;
+type TableSortState = TableSortState$1;
+type TableDefaultSort = TableSort;
+type TableDefaultSortDirection = TableSortDirection;
+type TableDensity = TableDensity$1;
+type TableCompoundType = {
+    <T>(props: TableProps<T>): ReactElement;
+    HeaderRow: typeof HeaderRow;
+    HeaderCell: typeof HeaderCell;
+    HeaderCellContent: typeof HeaderCellContent;
+    HeaderCellInteractive: typeof HeaderCellInteractive;
+    Row: typeof Row;
+    Cell: typeof Cell;
+    useTable: typeof useTable;
+    useRow: typeof useRow;
+    useCell: typeof useCell;
+    useCheckbox: typeof useCheckbox;
+    Empty: typeof TableEmpty;
+};
+declare const TableCompound: TableCompoundType;
+
+type TextAreaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'size'> & {
+    name: string;
+    id: string;
+    size?: 'md' | 'lg' | 'xl';
+    variant?: 'default' | 'secondary' | 'muted';
+    invalid?: boolean;
+    onValueChange?: (value: string) => void;
+    textAreaClassName?: string;
+};
+declare const TextArea: react__default.ForwardRefExoticComponent<Omit<react__default.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> & {
+    name: string;
+    id: string;
+    size?: "md" | "lg" | "xl";
+    variant?: "default" | "secondary" | "muted";
+    invalid?: boolean;
+    onValueChange?: (value: string) => void;
+    textAreaClassName?: string;
+} & react__default.RefAttributes<HTMLTextAreaElement>>;
+
+type TabsListProps = {
+    className?: string;
+    children: ReactNode;
+};
+declare const List$1: ({ className, children }: TabsListProps) => react__default.JSX.Element;
+
+type TabProps = HTMLAttributes<HTMLButtonElement | HTMLAnchorElement> & {
+    value: string;
+    className?: string;
+    children: ReactNode;
+    asLink?: boolean;
+    href?: string;
+    type?: 'button' | 'submit' | 'reset';
+    ref?: Ref<HTMLButtonElement | HTMLAnchorElement>;
+};
+declare const Tab: ({ value, className, children, onClick, asLink, href, type, ref, ...restProps }: TabProps) => react__default.JSX.Element;
+
+type TabsSize = 'md' | 'lg';
+interface TabsContextValue {
+    value: string;
+    onValueChange: (value: string) => void;
+    size: TabsSize;
+}
+declare const useTabs: () => TabsContextValue;
+
+type TabsProps = {
+    value: string;
+    onValueChange: (value: string) => void;
+    size?: TabsSize;
+    className?: string;
+    children: ReactNode;
+};
+
+type TabsCompoundType = {
+    (props: TabsProps): ReactElement;
+    List: typeof List$1;
+    Tab: typeof Tab;
+    useTabs: typeof useTabs;
+};
+declare const Tabs: TabsCompoundType;
+
+type ToggleItemProps = {
+    value: string;
+    className?: string;
+    children: ReactNode;
+};
+declare const Item: ({ value, className, children }: ToggleItemProps) => react__default.JSX.Element;
+
+type ToggleProps = {
+    value: string;
+    onValueChange: (value: string) => void;
+    disabled?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    children: ReactNode;
+};
+
+interface ToggleContextValue {
+    value: string;
+    onValueChange: (value: string) => void;
+    disabled: boolean;
+    size: 'sm' | 'md' | 'lg';
+    isBinaryToggle: boolean;
+    registerItem: (value: string, el: HTMLButtonElement | null) => void;
+    containerRef: RefObject<HTMLDivElement | null>;
+    itemRefs: RefObject<Map<string, HTMLButtonElement>>;
+}
+declare const useToggle: () => ToggleContextValue;
+
+type ToggleCompoundType = {
+    (props: ToggleProps): ReactElement;
+    Item: typeof Item;
+    useToggle: typeof useToggle;
+};
+declare const Toggle: ToggleCompoundType;
+
+interface CustomToastData {
+    content: ReactNode;
+    /** When true, the toast cannot be dismissed by swiping. Only programmatic close is allowed. */
+    persistent?: boolean;
+    /** Optional classes applied to the toast shell. */
+    className?: string;
+}
+declare const List: () => react__default.JSX.Element;
+
+type ToastProviderProps = ToastProviderProps$1 & {
+    children?: ReactNode;
+};
+declare const Provider: ({ children, ...props }: ToastProviderProps) => react__default.JSX.Element;
+declare const useToastManager: () => UseToastManagerReturnValue;
+
+type ToastCompoundType = {
+    List: typeof List;
+    Provider: typeof Provider;
+    useToastManager: typeof useToastManager;
+};
+declare const Toast: ToastCompoundType;
+type ToastManager = UseToastManagerReturnValue;
+
+type TooltipProps = TooltipProviderProps & TooltipRootProps & Omit<TooltipPositionerProps, 'className'> & {
+    children: ReactElement;
+    tip: ReactElement | string | null;
+    disableFocusTrigger?: boolean;
+    hoverable?: boolean;
+    className?: string;
+};
+declare const Tooltip: react__default.MemoExoticComponent<({ children, tip, delay, closeDelay, timeout, defaultOpen, open: controlledOpen, onOpenChange, onOpenChangeComplete, trackCursorAxis, disableFocusTrigger, hoverable, disabled, sideOffset, className, ...positionerProps }: TooltipProps) => react__default.JSX.Element>;
+
+interface CollapsedProps {
+    onExpand: () => void;
+}
+
+declare namespace Panels {
+    const Group: ({ orientation, onLayoutChanged, ...props }: GroupProps) => react.JSX.Element;
+    const Panel: ({ collapsible, collapsedSize, panelRef: panelRefProp, onResize: onResizeProp, onExpand: onExpandProp, onCollapse: onCollapseProp, defaultSize, children, ...props }: {
+        className?: string | undefined;
+        children?: react.ReactNode | undefined;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+        autoFocus?: boolean | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+        hidden?: boolean | undefined;
+        id?: string | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        slot?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        style?: react.CSSProperties | undefined;
+        tabIndex?: number | undefined;
+        title?: string | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: react.AriaRole | undefined;
+        about?: string | undefined;
+        content?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        color?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        popover?: "" | "auto" | "manual" | "hint" | undefined;
+        popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+        popoverTarget?: string | undefined;
+        inert?: boolean | undefined;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+        is?: string | undefined;
+        exportparts?: string | undefined;
+        part?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+        "aria-braillelabel"?: string | undefined;
+        "aria-brailleroledescription"?: string | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colindextext"?: string | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-description"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "true" | "false") | undefined;
+        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowindextext"?: string | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: react.ClipboardEventHandler<HTMLDivElement>;
+        onCopyCapture?: react.ClipboardEventHandler<HTMLDivElement>;
+        onCut?: react.ClipboardEventHandler<HTMLDivElement>;
+        onCutCapture?: react.ClipboardEventHandler<HTMLDivElement>;
+        onPaste?: react.ClipboardEventHandler<HTMLDivElement>;
+        onPasteCapture?: react.ClipboardEventHandler<HTMLDivElement>;
+        onCompositionEnd?: react.CompositionEventHandler<HTMLDivElement>;
+        onCompositionEndCapture?: react.CompositionEventHandler<HTMLDivElement>;
+        onCompositionStart?: react.CompositionEventHandler<HTMLDivElement>;
+        onCompositionStartCapture?: react.CompositionEventHandler<HTMLDivElement>;
+        onCompositionUpdate?: react.CompositionEventHandler<HTMLDivElement>;
+        onCompositionUpdateCapture?: react.CompositionEventHandler<HTMLDivElement>;
+        onFocus?: react.FocusEventHandler<HTMLDivElement>;
+        onFocusCapture?: react.FocusEventHandler<HTMLDivElement>;
+        onBlur?: react.FocusEventHandler<HTMLDivElement>;
+        onBlurCapture?: react.FocusEventHandler<HTMLDivElement>;
+        onChange?: react.ChangeEventHandler<HTMLDivElement, Element>;
+        onChangeCapture?: react.ChangeEventHandler<HTMLDivElement, Element>;
+        onBeforeInput?: react.InputEventHandler<HTMLDivElement>;
+        onBeforeInputCapture?: react.InputEventHandler<HTMLDivElement>;
+        onInput?: react.InputEventHandler<HTMLDivElement>;
+        onInputCapture?: react.InputEventHandler<HTMLDivElement>;
+        onReset?: react.ReactEventHandler<HTMLDivElement>;
+        onResetCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onSubmit?: react.SubmitEventHandler<HTMLDivElement>;
+        onSubmitCapture?: react.SubmitEventHandler<HTMLDivElement>;
+        onInvalid?: react.ReactEventHandler<HTMLDivElement>;
+        onInvalidCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onLoad?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onError?: react.ReactEventHandler<HTMLDivElement>;
+        onErrorCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onKeyDown?: react.KeyboardEventHandler<HTMLDivElement>;
+        onKeyDownCapture?: react.KeyboardEventHandler<HTMLDivElement>;
+        onKeyPress?: react.KeyboardEventHandler<HTMLDivElement>;
+        onKeyPressCapture?: react.KeyboardEventHandler<HTMLDivElement>;
+        onKeyUp?: react.KeyboardEventHandler<HTMLDivElement>;
+        onKeyUpCapture?: react.KeyboardEventHandler<HTMLDivElement>;
+        onAbort?: react.ReactEventHandler<HTMLDivElement>;
+        onAbortCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onCanPlay?: react.ReactEventHandler<HTMLDivElement>;
+        onCanPlayCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onCanPlayThrough?: react.ReactEventHandler<HTMLDivElement>;
+        onCanPlayThroughCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onDurationChange?: react.ReactEventHandler<HTMLDivElement>;
+        onDurationChangeCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onEmptied?: react.ReactEventHandler<HTMLDivElement>;
+        onEmptiedCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onEncrypted?: react.ReactEventHandler<HTMLDivElement>;
+        onEncryptedCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onEnded?: react.ReactEventHandler<HTMLDivElement>;
+        onEndedCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadedData?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadedDataCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadedMetadata?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadedMetadataCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadStart?: react.ReactEventHandler<HTMLDivElement>;
+        onLoadStartCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onPause?: react.ReactEventHandler<HTMLDivElement>;
+        onPauseCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onPlay?: react.ReactEventHandler<HTMLDivElement>;
+        onPlayCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onPlaying?: react.ReactEventHandler<HTMLDivElement>;
+        onPlayingCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onProgress?: react.ReactEventHandler<HTMLDivElement>;
+        onProgressCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onRateChange?: react.ReactEventHandler<HTMLDivElement>;
+        onRateChangeCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onSeeked?: react.ReactEventHandler<HTMLDivElement>;
+        onSeekedCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onSeeking?: react.ReactEventHandler<HTMLDivElement>;
+        onSeekingCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onStalled?: react.ReactEventHandler<HTMLDivElement>;
+        onStalledCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onSuspend?: react.ReactEventHandler<HTMLDivElement>;
+        onSuspendCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onTimeUpdate?: react.ReactEventHandler<HTMLDivElement>;
+        onTimeUpdateCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onVolumeChange?: react.ReactEventHandler<HTMLDivElement>;
+        onVolumeChangeCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onWaiting?: react.ReactEventHandler<HTMLDivElement>;
+        onWaitingCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onAuxClick?: react.MouseEventHandler<HTMLDivElement>;
+        onAuxClickCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onClick?: react.MouseEventHandler<HTMLDivElement>;
+        onClickCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onContextMenu?: react.MouseEventHandler<HTMLDivElement>;
+        onContextMenuCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onDoubleClick?: react.MouseEventHandler<HTMLDivElement>;
+        onDoubleClickCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onDrag?: react.DragEventHandler<HTMLDivElement>;
+        onDragCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDragEnd?: react.DragEventHandler<HTMLDivElement>;
+        onDragEndCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDragEnter?: react.DragEventHandler<HTMLDivElement>;
+        onDragEnterCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDragExit?: react.DragEventHandler<HTMLDivElement>;
+        onDragExitCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDragLeave?: react.DragEventHandler<HTMLDivElement>;
+        onDragLeaveCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDragOver?: react.DragEventHandler<HTMLDivElement>;
+        onDragOverCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDragStart?: react.DragEventHandler<HTMLDivElement>;
+        onDragStartCapture?: react.DragEventHandler<HTMLDivElement>;
+        onDrop?: react.DragEventHandler<HTMLDivElement>;
+        onDropCapture?: react.DragEventHandler<HTMLDivElement>;
+        onMouseDown?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseDownCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseEnter?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseLeave?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseMove?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseMoveCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseOut?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseOutCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseOver?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseOverCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseUp?: react.MouseEventHandler<HTMLDivElement>;
+        onMouseUpCapture?: react.MouseEventHandler<HTMLDivElement>;
+        onSelect?: react.ReactEventHandler<HTMLDivElement>;
+        onSelectCapture?: react.ReactEventHandler<HTMLDivElement>;
+        onTouchCancel?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchCancelCapture?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchEnd?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchEndCapture?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchMove?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchMoveCapture?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchStart?: react.TouchEventHandler<HTMLDivElement>;
+        onTouchStartCapture?: react.TouchEventHandler<HTMLDivElement>;
+        onPointerDown?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerDownCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerMove?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerMoveCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerUp?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerUpCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerCancel?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerCancelCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerEnter?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerLeave?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerOver?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerOverCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerOut?: react.PointerEventHandler<HTMLDivElement>;
+        onPointerOutCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onGotPointerCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onGotPointerCaptureCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onLostPointerCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onLostPointerCaptureCapture?: react.PointerEventHandler<HTMLDivElement>;
+        onScroll?: react.UIEventHandler<HTMLDivElement>;
+        onScrollCapture?: react.UIEventHandler<HTMLDivElement>;
+        onScrollEnd?: react.UIEventHandler<HTMLDivElement>;
+        onScrollEndCapture?: react.UIEventHandler<HTMLDivElement>;
+        onWheel?: react.WheelEventHandler<HTMLDivElement>;
+        onWheelCapture?: react.WheelEventHandler<HTMLDivElement>;
+        onAnimationStart?: react.AnimationEventHandler<HTMLDivElement>;
+        onAnimationStartCapture?: react.AnimationEventHandler<HTMLDivElement>;
+        onAnimationEnd?: react.AnimationEventHandler<HTMLDivElement>;
+        onAnimationEndCapture?: react.AnimationEventHandler<HTMLDivElement>;
+        onAnimationIteration?: react.AnimationEventHandler<HTMLDivElement>;
+        onAnimationIterationCapture?: react.AnimationEventHandler<HTMLDivElement>;
+        onToggle?: react.ToggleEventHandler<HTMLDivElement>;
+        onBeforeToggle?: react.ToggleEventHandler<HTMLDivElement>;
+        onTransitionCancel?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionCancelCapture?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionEnd?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionEndCapture?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionRun?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionRunCapture?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionStart?: react.TransitionEventHandler<HTMLDivElement>;
+        onTransitionStartCapture?: react.TransitionEventHandler<HTMLDivElement>;
+    } & {
+        className?: string | undefined;
+        collapsedSize?: number | string | undefined;
+        collapsible?: boolean | undefined;
+        defaultSize?: number | string | undefined;
+        disabled?: boolean | undefined;
+        elementRef?: react.Ref<HTMLDivElement | null> | undefined;
+        groupResizeBehavior?: "preserve-relative-size" | "preserve-pixel-size" | undefined;
+        id?: string | number | undefined;
+        maxSize?: number | string | undefined;
+        minSize?: number | string | undefined;
+        onResize?: ((panelSize: PanelSize, id: string | number | undefined, prevPanelSize: PanelSize | undefined) => void) | undefined;
+        panelRef?: react.Ref<PanelImperativeHandle | null> | undefined;
+        style?: react.CSSProperties | undefined;
+    } & {
+        children?: react.ReactNode;
+        onExpand?: () => void;
+        onCollapse?: () => void;
+    }) => react.JSX.Element;
+    const Separator: ({ elementRef, className, ...props }: Omit<SeparatorProps$1, "elementRef"> & {
+        elementRef?: SeparatorProps$1["elementRef"];
+    }) => react.JSX.Element;
+    const Collapsed: react.FC<CollapsedProps>;
+    const isCoarsePointer: typeof isCoarsePointer;
+    const useDefaultLayout: typeof useDefaultLayout;
+    const useGroupCallbackRef: typeof useGroupCallbackRef;
+    const useGroupRef: typeof useGroupRef;
+    const usePanelCallbackRef: typeof usePanelCallbackRef;
+    const useOrientation: () => "horizontal" | "vertical";
+    const usePanelRef: typeof usePanelRef;
+    type GroupImperativeHandle = GroupImperativeHandle;
+    type GroupProps = GroupProps;
+    type Layout = Layout;
+    type LayoutStorage = LayoutStorage;
+    type OnGroupLayoutChange = OnGroupLayoutChange;
+    type OnPanelResize = OnPanelResize;
+    type Orientation = Orientation;
+    type PanelImperativeHandle = PanelImperativeHandle;
+    type PanelProps = PanelProps;
+    type PanelSize = PanelSize;
+    type SeparatorProps = SeparatorProps$1;
+    type SizeUnit = SizeUnit;
+    type CollapsedProps = CollapsedProps;
+}
+
+interface ScrollAreaState {
+    hasOverflow: boolean;
+}
+type ScrollAreaSize = 'sm' | 'md';
+interface ScrollAreaProps {
+    children: ReactNode | ((state: ScrollAreaState) => ReactNode);
+    className?: string;
+    size?: ScrollAreaSize;
+}
+declare const ScrollArea: ({ children, className, size }: ScrollAreaProps) => react__default.JSX.Element;
+
+type PaginationMetadata = {
+    totalPages: number;
+    perPage: number;
+};
+type PaginationProps = {
+    pagination: PaginationMetadata;
+    page: number;
+    onClick: (page: number) => void;
+    className?: string;
+};
+declare const Pagination: FC<PaginationProps>;
+
+interface PageHeaderProps {
+    title: string;
+    children?: ReactNode;
+}
+/** The standard heading row for a Toolpath application page. */
+declare const PageHeader: ({ title, children }: PageHeaderProps) => react.JSX.Element;
+
+export { Attribution, type AttributionActionProps, type AttributionAtProps, type AttributionByProps, type AttributionProps, Badge, type BadgeProps, Breadcrumbs, type BreadcrumbsItemProps, type BreadcrumbsProps, Button$1 as Button, type ButtonProps, Callout, type CalloutProps, Card, type CardProps, Checkbox, type CheckboxChangeEvent, type CheckboxProps, Combobox, type ComboboxButtonProps, type ComboboxEmptyProps, type ComboboxGroupLabelProps, type ComboboxGroupProps, type ComboboxIconProps, type ComboboxInputProps, type ComboboxItemIndicatorProps, type ComboboxItemProps, type ComboboxListProps, type ComboboxPopoverProps, type ComboboxProps, type ComboboxTriggerProps, type ComboboxValueProps, type CustomToastData, Dialog, type DialogActionsProps, type DialogConfirmProps, type DialogDismissProps, type DialogMessageProps, type DialogProviderProps, type DialogRootProps, type DialogTitleProps, EditableCell, type EditableCellProps, type EditableGridOptions, type EditingCell$1 as EditingCell, Field, type FieldProps, IconButton, type IconButtonIndicatorProps, type IconButtonProps, Input, type InputProps, Link, type LinkComponentProps, type LinkProps, LinkProvider, type LinkProviderProps, Menu, type MenuDividerProps, type MenuItemProps, type MenuPopoverProps, type MenuProps, type MenuSubmenuRootProps, type MenuSubmenuTriggerProps, type MenuTriggerProps, type NavigateDirection, Notification, type NotificationManager, PageHeader, type PageHeaderProps, Pagination, type PaginationMetadata, type PaginationProps, Panels, Pin, type PinChangeEvent, type PinProps, ProgressBar, type ProgressBarProps, type ProgressBarSize, QuantityInput, type QuantityInputProps, ScrollArea, type ScrollAreaProps, type ScrollAreaSize, type ScrollAreaState, Slider, type SliderProps, Star, type StarChangeEvent, type StarProps, Switch, type SwitchProps, type TabProps, TableCompound as Table, type TableDefaultSort, type TableDefaultSortDirection, type TableDensity, type TableSelectedRows, type TableSortState, Tabs, type TabsListProps, type TabsProps, type TabsSize, TextArea, type TextAreaProps, Toast, type ToastManager, type ToastProviderProps, Toggle, type ToggleItemProps, type ToggleProps, Tooltip, type TooltipProps, useDismissedCallouts, useEditableGrid, useLinkContext };