@semio/ui 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,1194 @@
+import * as react from 'react';
+import react__default, { ReactNode, MutableRefObject, CSSProperties, MouseEventHandler, MouseEvent as MouseEvent$1, RefObject, InputHTMLAttributes, ChangeEvent, TextareaHTMLAttributes, FocusEventHandler, ButtonHTMLAttributes } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { CollapsibleContentProps, CollapsibleTriggerProps, CollapsibleProps } from '@radix-ui/react-collapsible';
+import { RawColor } from '@semio/utils';
+import { ReferenceType, useFloating, VirtualElement } from '@floating-ui/react';
+import { Accept } from 'react-dropzone';
+import { TablerIconsProps } from '@tabler/icons-react';
+
+/**
+ * Theme options for the application's appearance.
+ *
+ * Includes Light, Dark, and System themes
+ */
+declare enum Theme {
+    /**
+     * Light theme with bright background and dark text.
+     */
+    Light = "light",
+    /**
+     * Dark theme with dark background and light text.
+     */
+    Dark = "dark",
+    /**
+     * Follows the system's theme settings.
+     */
+    System = "system"
+}
+/**
+ * Visual variants for UI components.
+ *
+ * Includes Primary, Secondary, Tertiary, Default, Info, Success, Warning, and Error variants
+ */
+declare enum Variant {
+    /**
+     * Main emphasis, used for primary actions.
+     */
+    Primary = "primary",
+    /**
+     * Less emphasis than primary, used for secondary actions.
+     */
+    Secondary = "secondary",
+    /**
+     * Minimal emphasis, used for tertiary actions.
+     */
+    Tertiary = "tertiary",
+    /**
+     * Standard styling without emphasis.
+     */
+    Default = "default",
+    /**
+     * Used for informational messages or states.
+     */
+    Info = "info",
+    /**
+     * Indicates successful operations or states.
+     */
+    Success = "success",
+    /**
+     * Indicates cautionary messages or states.
+     */
+    Warning = "warning",
+    /**
+     * Indicates error messages or states.
+     */
+    Error = "error"
+}
+/**
+ * Size options for UI components.
+ *
+ * Includes Extra Small (Xs), Small (Sm), Medium (Md), and Large (Lg) sizes
+ */
+declare enum Size {
+    /**
+     * Extra small size.
+     */
+    Xs = "xs",
+    /**
+     * Small size.
+     */
+    Sm = "sm",
+    /**
+     * Medium size (default).
+     */
+    Md = "md",
+    /**
+     * Large size.
+     */
+    Lg = "lg"
+}
+/**
+ * Time display format options.
+ *
+ * Includes Frames, Seconds+Milliseconds, Minutes+Seconds+Milliseconds, Seconds+Frames, and Seconds
+ */
+declare enum TimeDisplay {
+    /**
+     * Display time in frames only.
+     */
+    Frames = "frames",
+    /**
+     * Display time in seconds and milliseconds format.
+     */
+    SecondsPlusMilliseconds = "seconds+milliseconds",
+    /**
+     * Display time in minutes, seconds, and milliseconds format.
+     */
+    MinutesPlusSecondsPlusMilliseconds = "minutes+seconds+milliseconds",
+    /**
+     * Display time in seconds and frames format.
+     */
+    SecondsPlusFrames = "seconds+frames",
+    /**
+     * Display time in seconds only.
+     */
+    Seconds = "seconds"
+}
+/**
+ * Types of nested parent components.
+ *
+ * Includes Context and Dropdown parents
+ */
+declare enum NestedParent {
+    /**
+     * Parent is a context component.
+     */
+    Context = "context",
+    /**
+     * Parent is a dropdown component.
+     */
+    Dropdown = "dropdown"
+}
+
+declare function stampToVisualTime(stamp: number, duration: number, framerate: number, timeDisplay: TimeDisplay, showDetail?: boolean): string;
+
+interface LayoutProps {
+    menu: ReactNode;
+    leftSidebar?: ReactNode;
+    rightSidebar?: ReactNode;
+    bottomPanel?: ReactNode;
+    children: ReactNode;
+    menuRef?: MutableRefObject<HTMLDivElement | null>;
+    leftSidebarRef?: MutableRefObject<HTMLDivElement | null>;
+    rightSidebarRef?: MutableRefObject<HTMLDivElement | null>;
+    bottomPanelRef?: MutableRefObject<HTMLDivElement | null>;
+    style?: CSSProperties;
+    gradient?: boolean;
+    className?: string;
+}
+/**
+ * Renders the inner layout of the application.
+ *
+ * TODO: Update with resizeable panes and pop out windows.
+ *
+ * @param menu - The menu component.
+ * @param leftSidebar - The left sidebar component.
+ * @param rightSidebar - The right sidebar component.
+ * @param bottomPanel - The bottom panel component.
+ * @param children - The content to be rendered in the main body.
+ */
+declare function InnerLayout({ menu, leftSidebar, rightSidebar, bottomPanel, children, menuRef, leftSidebarRef, rightSidebarRef, bottomPanelRef, style, gradient, className, }: LayoutProps): react_jsx_runtime.JSX.Element;
+declare const Layout: react.MemoExoticComponent<typeof InnerLayout>;
+
+interface Step {
+    label: string;
+    completed: boolean;
+    disabled: boolean;
+    content?: ReactNode;
+}
+interface VerticalStepperProps {
+    steps: Step[];
+    activeStep?: number;
+    onStepChange: (step: number) => void;
+}
+declare function VerticalStepper({ steps, onStepChange, activeStep }: VerticalStepperProps): react_jsx_runtime.JSX.Element;
+
+interface MenuProps {
+    header?: ReactNode;
+    footer?: ReactNode;
+    children: ReactNode;
+}
+declare function Menu({ header, footer, children }: MenuProps): react_jsx_runtime.JSX.Element;
+declare function useMenu(): {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+
+/**
+ * Renders a spinner component. If children are provided, the spinner will bounce and spin the child,
+ * Otherwise, it will render a default spinner, an animated semi-circle.
+ *
+ * @example
+ * ```tsx
+ * <Spinner>
+ *   <img src="spinner.gif" alt="Loading..." />
+ * </Spinner>
+ * ```
+ */
+declare function Spinner({ children }: {
+    children?: ReactNode;
+}): ReactNode;
+
+interface StatusProps {
+    variant?: Variant;
+    placement?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    children: ReactNode;
+    text?: string;
+    hidden?: boolean;
+}
+declare const Status: react.ForwardRefExoticComponent<StatusProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ProgressProps {
+    progress: number;
+    color?: string;
+}
+declare function Progress({ progress, color }: ProgressProps): react_jsx_runtime.JSX.Element;
+
+interface SidebarChild {
+    title: string;
+    key: string;
+    content: ReactNode;
+}
+interface SidebarProps {
+    children: SidebarChild[];
+    sidebar: string | null;
+    side?: "left" | "right";
+}
+declare function Sidebar({ children, sidebar, side }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode;
+    altText?: string;
+    disabled?: boolean;
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+    variant?: Variant;
+    color?: string;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    size?: Size | "fit";
+    deemphasize?: boolean;
+    invert?: boolean;
+    border?: boolean;
+    submit?: boolean;
+}
+/**
+ * A button that displays text and/or icons. If no text and one icon is provided, the button will be a square with padding.
+ * @param children - The text to display on the button
+ * @param altText - The alt text to accompany the button
+ * @param disabled - Whether the button is disabled
+ * @param onClick - Optional click handler
+ * @param variant - Optional variant to apply to the button (default is "default")
+ * @param color - Optional custom color to apply to the button
+ * @param leftIcon - Optional left icon to add to the button
+ * @param rightIcon - Optional right icon to add to the button
+ * @param size - Optional size to apply to the button
+ * @param deemphasize - Whether to deemphasize the button (subtler background and colored text)
+ * @param invert - Whether to invert the button colors (no background and colored text)
+ * @param border - Whether to add a border to the button
+ */
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ModalProps {
+    children: ReactNode;
+    open: boolean;
+    title?: string | ReactNode;
+    description?: string | ReactNode;
+    headerBottom?: ReactNode;
+    dismissDisabled?: boolean;
+    submitDisabled?: boolean;
+    submitText?: string;
+    onStateChange: (open: boolean) => void;
+    onSubmit?: (event: MouseEvent$1) => void;
+    onCancel?: (event: MouseEvent$1) => void;
+    variant?: Variant;
+    scrollDisabled?: boolean;
+}
+declare function Modal({ children, open, title, description, headerBottom, dismissDisabled, submitDisabled, submitText, onStateChange, onSubmit, onCancel, variant, scrollDisabled, }: ModalProps): react_jsx_runtime.JSX.Element;
+
+interface DialogProps {
+    children: ReactNode;
+    open: boolean;
+    title?: ReactNode;
+    description?: string;
+    submitDisabled?: boolean;
+    submitText?: string;
+    onStateChange: (open: boolean) => void;
+    onSubmit?: (event: MouseEvent$1) => void;
+    onCancel?: (event: MouseEvent$1) => void;
+    variant?: Variant;
+}
+declare function Dialog({ children, open, title, description, submitDisabled, submitText, onStateChange, onSubmit, onCancel, variant, }: DialogProps): react_jsx_runtime.JSX.Element;
+
+interface CheckboxProps {
+    id?: string;
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    variant?: Variant;
+    size?: Size;
+    disabled?: boolean;
+    invert?: boolean;
+}
+declare function Checkbox({ id, checked, onCheckedChange, variant, size, disabled, invert, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface AnchorProps {
+    onClick: () => void;
+    variant?: Variant;
+    children: string;
+}
+declare function Anchor({ onClick, variant, children }: AnchorProps): react_jsx_runtime.JSX.Element;
+
+interface ImageButtonProps {
+    imageUrl: string;
+    altText: string;
+    hoverText?: string;
+    dimensions?: {
+        width: string;
+        height: string;
+    };
+    onClick: () => void;
+}
+declare function ImageButton({ imageUrl, altText, hoverText, dimensions, onClick, }: ImageButtonProps): JSX.Element;
+
+interface MenuButtonProps {
+    id: string;
+    children: ReactNode;
+    title: ReactNode;
+    altLabel?: string;
+    variant?: Variant.Primary | Variant.Secondary | Variant.Tertiary | Variant.Default;
+    onClick?: MouseEventHandler;
+    active?: boolean;
+    status?: {
+        variant?: Variant;
+        placement?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+        text?: string;
+    };
+    hoverable?: boolean;
+}
+declare function MenuButton({ id, children, title, altLabel, variant, onClick, active, status, hoverable, }: MenuButtonProps): react_jsx_runtime.JSX.Element;
+
+interface AvatarProps {
+    src?: string;
+    icon?: React.ReactNode;
+    alt: string;
+    size?: Size;
+    rounded?: boolean;
+    onClick?: MouseEventHandler<HTMLSpanElement>;
+    variant?: Variant;
+    border?: Variant;
+    noHover?: boolean;
+    status?: {
+        variant?: Variant;
+        placement?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+        text?: string;
+    };
+    className?: string;
+}
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface CollapseProps {
+    title: string | ReactNode;
+    children: ReactNode;
+    onStateChange?: (open: boolean) => void;
+    open?: boolean;
+    direction?: "vertical" | "horizontal";
+    disabled?: boolean;
+    side?: "left" | "right";
+}
+declare function Collapse({ open, title, onStateChange, children, direction, disabled, side, }: CollapseProps): ReactNode;
+declare function CollapsibleContent(props: CollapsibleContentProps): react_jsx_runtime.JSX.Element;
+declare function CollapsibleTrigger(props: CollapsibleTriggerProps): react_jsx_runtime.JSX.Element;
+declare function CollapsibleRoot(props: CollapsibleProps): react_jsx_runtime.JSX.Element;
+
+interface AccordionProps {
+    sticky?: boolean;
+    stickyOffset?: number;
+    items: {
+        header: string;
+        content: react__default.ReactNode;
+        key: string;
+    }[];
+    defaultOpen?: boolean;
+}
+declare function Accordion({ items, defaultOpen, sticky, stickyOffset }: AccordionProps): react_jsx_runtime.JSX.Element;
+
+interface PopoverProps {
+    title?: string;
+    trigger: ReactNode;
+    content: ReactNode;
+    open?: boolean;
+    onStateChange?: (open: boolean) => void;
+    variant?: Variant;
+}
+declare function Popover({ title, trigger, content, open, onStateChange, variant }: PopoverProps): react_jsx_runtime.JSX.Element;
+
+interface TabChild {
+    title: string;
+    key: string;
+    content: ReactNode;
+}
+interface TabsProps {
+    children: TabChild[];
+    selected?: string;
+    onTabChange: (key: string) => void;
+    leftWidget?: ReactNode;
+    rightWidget?: ReactNode;
+    defaultContent?: ReactNode;
+    emptyTabText?: string;
+}
+declare function Tabs({ children, selected, onTabChange, leftWidget, rightWidget, defaultContent, emptyTabText, }: TabsProps): ReactNode;
+
+interface BasicRowData {
+    id: string;
+}
+interface ColumnDefinition<T extends BasicRowData> {
+    key: string;
+    header: ReactNode;
+    align?: "left" | "center" | "right";
+    flex?: boolean;
+    requiredSize?: Size;
+    render: (value: T) => ReactNode;
+}
+interface TableListProps<T extends BasicRowData> {
+    data: T[];
+    columns: ColumnDefinition<T>[];
+    headerOffset?: number;
+    noHeader?: boolean;
+    rowClassName?: string;
+    fullWidth?: boolean;
+    headerClassName?: string;
+    backgroundClassName?: string;
+    notFound?: ReactNode;
+    onFocusChange?: (focusedRow?: string) => void;
+    onRowEnter?: (row: string) => void;
+    onRowClick?: (row: string) => void;
+    selection?: string[];
+    transparentHeader?: boolean;
+}
+declare function TableList<T extends BasicRowData>({ data, columns, headerOffset, noHeader, rowClassName, headerClassName, backgroundClassName, notFound, onFocusChange, onRowEnter, onRowClick, selection, transparentHeader, }: TableListProps<T>): react_jsx_runtime.JSX.Element;
+
+interface DropdownProps {
+    trigger: ReactNode;
+    children: ReactNode;
+    variant?: Variant;
+    header?: ReactNode;
+}
+declare const Dropdown: react.ForwardRefExoticComponent<DropdownProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ToastState {
+    toasts: ToastData[];
+    addToast: (toast: ToastData) => void;
+    removeToast: (id: string) => void;
+    clear: () => void;
+}
+declare const ToastContext: react.Context<ToastState>;
+interface ToastManagerProps {
+    config?: {
+        tension: number;
+        friction: number;
+        precision: number;
+    };
+    timeout?: number;
+    children?: ReactNode;
+}
+interface ToastData {
+    id: string;
+    title: string;
+    content: string;
+    variant?: Variant;
+    dismiss?: {
+        label: string;
+        onClick: (data: ToastData) => void;
+    } | number;
+}
+interface ToastContainerProps {
+    children?: ReactNode;
+}
+declare function InnerToastManager({ children }: ToastContainerProps): react_jsx_runtime.JSX.Element;
+declare const ToastManager: react.MemoExoticComponent<typeof InnerToastManager>;
+
+interface ToggleGroupProps {
+    variant?: Variant;
+    value: string;
+    onChange: (value: string) => void;
+    label?: string;
+    options: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+        color?: string;
+        icon?: ReactNode;
+    }[];
+    size?: Size;
+}
+declare function ToggleGroup({ variant, value, onChange, options, size, label }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
+
+interface ToggleSquareProps {
+    variant?: Variant;
+    value: boolean;
+    disabled?: boolean;
+    onChange: (value: boolean) => void;
+    label?: string;
+    children?: ReactNode;
+    size?: Size;
+}
+declare function ToggleSquare({ variant, value, disabled, onChange, size, label, children, }: ToggleSquareProps): react_jsx_runtime.JSX.Element;
+
+interface ContextMenuProps {
+    trigger: ReactNode;
+    children: ReactNode;
+    variant?: Variant;
+}
+declare function ContextMenu({ trigger, children, variant }: ContextMenuProps): react_jsx_runtime.JSX.Element;
+
+interface SeparatorProps {
+    children?: ReactNode;
+    variant?: Variant | "custom" | "layout";
+    color?: string;
+    orientation?: "horizontal" | "vertical";
+    className?: string;
+}
+declare function Separator({ children, variant, color, orientation, className, }: SeparatorProps): react_jsx_runtime.JSX.Element;
+
+interface NestedItemProps {
+    left?: ReactNode;
+    children: ReactNode;
+    right?: ReactNode;
+    variant?: Variant;
+    disabled?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+}
+declare function NestedItem({ left, children, right, variant, disabled, onClick }: NestedItemProps): react_jsx_runtime.JSX.Element;
+
+interface NestedSeparatorProps {
+    variant?: Variant;
+}
+declare function NestedSeparator({ variant }: NestedSeparatorProps): react_jsx_runtime.JSX.Element;
+
+interface NestedRadioProps {
+    variant?: Variant;
+    disabled?: boolean;
+    onChange?: (value: string) => void;
+    value?: string;
+    options: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+        color?: string;
+        icon?: ReactNode;
+    }[];
+}
+declare function NestedRadio({ variant, disabled, onChange, value, options }: NestedRadioProps): react_jsx_runtime.JSX.Element;
+
+interface NestedSelectProps {
+    variant?: Variant;
+    disabled?: boolean;
+    onChange?: (value: string[]) => void;
+    values: string[];
+    options: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+        color?: string;
+        icon?: ReactNode;
+    }[];
+}
+declare function NestedSelect({ variant, disabled, onChange, values, options }: NestedSelectProps): react_jsx_runtime.JSX.Element;
+
+interface NestedMenuProps {
+    left?: ReactNode;
+    children: ReactNode;
+    label?: string;
+    variant?: Variant;
+    labelVariant?: Variant;
+    disabled?: boolean;
+}
+declare function NestedMenu({ left, children, label, variant, labelVariant, disabled, }: NestedMenuProps): react_jsx_runtime.JSX.Element;
+
+interface NestedLabelProps {
+    children: ReactNode;
+}
+declare function NestedLabel({ children }: NestedLabelProps): react_jsx_runtime.JSX.Element;
+
+interface NestedColorPickerProps<T extends string | RawColor> {
+    value: T;
+    onChange: (value: T) => void;
+    disabled?: boolean;
+    label?: string;
+    variant?: Variant;
+}
+declare function NestedColorPicker<T extends string | RawColor>({ value, onChange, disabled, label, variant, }: NestedColorPickerProps<T>): react_jsx_runtime.JSX.Element;
+
+interface NestedCheckboxProps {
+    variant?: Variant;
+    onChange?: (value: boolean) => void;
+    value: boolean;
+    label: string;
+    color?: string;
+    disabled?: boolean;
+    icon?: ReactNode;
+}
+declare function NestedCheckbox({ variant, disabled, onChange, value, color, icon, label, }: NestedCheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface TooltipProps {
+    content: ReactNode;
+    children: ReactNode;
+    side?: "top" | "right" | "bottom" | "left";
+    controlledState?: [boolean, (value: boolean) => void];
+    variant?: Variant;
+    disabled?: boolean;
+    invert?: boolean;
+}
+declare function Tooltip({ content, children, side, controlledState, variant, disabled, invert, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+type FloatingResults = ReturnType<typeof useFloating>;
+interface ElementRefs {
+    triggerRef: ((instance: Element | VirtualElement | null) => void) | null;
+    floatingRef: ((instance: Element | VirtualElement | null) => void) | null;
+}
+interface TrackedTooltipResult extends FloatingResults {
+    elementRefs: ElementRefs;
+    updateHoverState: (x: number | undefined, y: number | undefined, hovering: boolean) => void;
+}
+declare function useTrackedTooltip(triggerRef: RefObject<ReferenceType>, floatingRef: RefObject<ReferenceType>, side: "top" | "right" | "bottom" | "left", axis: "x" | "y" | "both", sideOffset?: number): TrackedTooltipResult;
+interface TrackedTooltipProps {
+    children: ReactNode;
+    containerStyles: CSSProperties;
+    variant?: Variant;
+    open?: boolean;
+}
+declare const TrackedTooltip: react.ForwardRefExoticComponent<TrackedTooltipProps & react.RefAttributes<HTMLDivElement>>;
+
+interface ColorPickerInputProps<T extends string | RawColor> {
+    value: T;
+    onChange: (color: T) => void;
+}
+declare function ColorPickerInput<T extends string | RawColor>({ value, onChange, }: ColorPickerInputProps<T>): react_jsx_runtime.JSX.Element;
+
+interface ColorPickerPopoverProps<T extends string | RawColor> {
+    value: T;
+    onChange: (color: T) => void;
+}
+declare function ColorPickerPopover<T extends string | RawColor>({ value, onChange, }: ColorPickerPopoverProps<T>): react_jsx_runtime.JSX.Element;
+
+declare function NumberOrListInput({ value, onChange, title, }: {
+    value: number | number[];
+    onChange: (value: number | number[]) => void;
+    title?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface EmailInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    invalid?: boolean;
+    message?: string;
+    size?: Size;
+    variant?: Variant;
+}
+declare const EmailInput: react.ForwardRefExoticComponent<EmailInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface FileInputProps {
+    fileObj: File | null;
+    setFile: (file: File | null) => void;
+    handleFileChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    types?: string;
+    inputTitle?: string;
+}
+declare function FileInput({ fileObj, setFile, handleFileChange, types, inputTitle, }: FileInputProps): react_jsx_runtime.JSX.Element;
+
+interface EmailsInputProps {
+    emails: string[];
+    fieldName?: string;
+    onEmailsChange: (emails: string[], field: string) => void;
+    inputPlaceholder?: string;
+    inputTitle?: string;
+}
+declare function EmailsInput({ emails: initialEmails, fieldName, onEmailsChange, inputTitle, inputPlaceholder, }: EmailsInputProps): react_jsx_runtime.JSX.Element;
+
+interface ImageInputProps {
+    imageUrl?: string;
+    onImageChange: (file: File | null) => void;
+    uploading?: boolean;
+    inputTitle?: string;
+}
+declare function ImageInput({ imageUrl, onImageChange, uploading, inputTitle, }: ImageInputProps): react_jsx_runtime.JSX.Element;
+
+interface PasswordInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    invalid?: boolean;
+    message?: string;
+    size?: Size;
+    variant?: Variant;
+    showPassword?: boolean;
+}
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SwitchProps {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    disabled?: boolean;
+    variant?: Variant;
+    offVariant?: Variant;
+    onIcon?: ReactNode;
+    offIcon?: ReactNode;
+    size?: "sm" | "md" | "lg";
+    square?: boolean;
+}
+declare function Switch({ value, onChange, disabled, variant, size, onIcon, offIcon, offVariant, square, }: SwitchProps): react_jsx_runtime.JSX.Element;
+
+interface SearchAdditionalProps {
+    onChange?: (value: string) => void;
+    onSearch?: (value: string) => void;
+    variant?: Variant;
+    size?: Size;
+}
+type SearchProps = SearchAdditionalProps & Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "onChange">;
+/**
+ * Inherits from standard Input HTML element
+ * @param value - the value of the field
+ * @param onChange - the callback to call when the value changes
+ * @param size - the size of the field
+ * @param variant - the variant of the field
+ */
+declare function InnerSearch({ size, onChange, onSearch, variant, ...forwardedProps }: SearchProps): ReactNode;
+declare const Search: react.MemoExoticComponent<typeof InnerSearch>;
+
+interface StringsInputProps {
+    strings: string[];
+    fieldName: string;
+    onStringsChange: (strings: string[], field: string) => void;
+    inputPlaceholder?: string;
+    inputTitle?: string;
+}
+declare function StringsInput({ strings, fieldName, onStringsChange, inputTitle, inputPlaceholder, }: StringsInputProps): react_jsx_runtime.JSX.Element;
+
+interface TimeInputProps extends Omit<React.HTMLAttributes<HTMLInputElement>, "onChange"> {
+    value: number | undefined;
+    onChange: (value: number) => void;
+    framerate: number;
+    display?: TimeDisplay;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    variant: Variant;
+    size?: Size;
+    bg?: boolean;
+    label?: string;
+    hidden?: boolean;
+}
+declare function TimeInput({ value, onChange, framerate, display, disabled, variant, size, min, max, bg, label, hidden, }: TimeInputProps): react_jsx_runtime.JSX.Element;
+
+interface TextFieldProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "onChange"> {
+    onChange?: (value: string) => void;
+    variant?: Variant;
+    size?: Size;
+    bg?: boolean;
+    outline?: boolean;
+    subtle?: boolean;
+}
+declare const TextField: react.MemoExoticComponent<react.ForwardRefExoticComponent<TextFieldProps & react.RefAttributes<HTMLInputElement>>>;
+
+interface InputProps {
+    size: Size;
+    focused?: boolean;
+    cursor?: string;
+    bold?: boolean;
+    className?: string;
+    flex?: boolean;
+    subtle?: boolean;
+}
+declare const StyledInput: react.MemoExoticComponent<react.ForwardRefExoticComponent<InputProps & Omit<InputHTMLAttributes<HTMLInputElement>, "size"> & react.RefAttributes<HTMLInputElement>>>;
+
+interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size" | "onChange"> {
+    onChange?: (value: string) => void;
+    variant?: Variant;
+    size?: Size;
+    bg?: boolean;
+    outline?: boolean;
+    subtle?: boolean;
+}
+declare const TextArea: react.MemoExoticComponent<react.ForwardRefExoticComponent<TextAreaProps & react.RefAttributes<HTMLTextAreaElement>>>;
+declare const StyledArea: react.MemoExoticComponent<react.ForwardRefExoticComponent<InputProps & Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> & react.RefAttributes<HTMLTextAreaElement>>>;
+
+interface TextInputProps {
+    textValue: string;
+    fieldName: string;
+    onTextChange: (value: string, field: string) => void;
+    inputTitle?: string;
+    inputPlaceholder?: string;
+    inputSize?: number;
+}
+declare function TextInput({ textValue, fieldName, onTextChange, inputTitle, inputPlaceholder, inputSize, }: TextInputProps): react_jsx_runtime.JSX.Element;
+
+interface BasicNumberFieldProps {
+    id?: string;
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    units?: string;
+    color?: string;
+    strict?: boolean;
+    emphasis?: boolean;
+    size?: Size;
+    inactive?: boolean;
+    disabled?: boolean;
+    label?: string;
+    onLabelChange?: (label: string) => void;
+    onEmphasisChange?: (emphasis: boolean) => void;
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+}
+/**
+ * BasicNumberField
+ * @param {string} id - the id of the field
+ * @param {number} value:  - the value of the field
+ * @param onChange: (value: number) => void - the function to call when the value changes
+ * @param min?: number - the minimum value
+ * @param max?: number - the maximum value
+ * @param visualMin?: number - the minimum visual value
+ * @param visualMax?: number - the maximum visual value
+ * @param units?: string - the units to display
+ * @param color?: string - the color of the slider
+ * @param strictSlider?: boolean - whether to enforce the slider bounds
+ * @param strictText?: boolean - whether to enforce the text bounds
+ * @param emphasis?: boolean - whether the field is emphasized
+ * @param size?: Size - the size of the field
+ * @param inactive?: boolean - whether the field is inactive
+ * @param disabled?: boolean - whether the field is disabled
+ * @param label?: string - the label of the field
+ * @param onLabelChange?: (label: string) => void - the function to call when the label changes
+ * @param onEmphasisChange?: (emphasis: boolean) => void - the function to call when the emphasis changes
+ * @param onFocus?: FocusEventHandler;
+ * @param onBlur?: FocusEventHandler;
+ */
+declare function InnerBasicNumberField({ value, onChange, min, max, units, color, strict, emphasis, size, inactive, disabled, onEmphasisChange, onBlur: onBlurExternal, onFocus: onFocusExternal, }: BasicNumberFieldProps): ReactNode;
+declare const BasicNumberField: react.MemoExoticComponent<typeof InnerBasicNumberField>;
+
+interface SliderNumberFieldProps {
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    visualMin?: number;
+    visualMax?: number;
+    units?: string;
+    color?: string;
+    strictSlider?: boolean;
+    strictText?: boolean;
+    emphasis?: boolean;
+    size?: Size;
+    inactive?: boolean;
+    disabled?: boolean;
+    label?: string;
+    onLabelChange?: (label: string) => void;
+    onEmphasisChange?: (emphasis: boolean) => void;
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+}
+/**
+ * SliderNumberField
+ * @param {number} value:  - the value of the field
+ * @param onChange: (value: number) => void - the function to call when the value changes
+ * @param min?: number - the minimum value
+ * @param max?: number - the maximum value
+ * @param visualMin?: number - the minimum visual value
+ * @param visualMax?: number - the maximum visual value
+ * @param units?: string - the units to display
+ * @param color?: string - the color of the slider
+ * @param strictSlider?: boolean - whether to enforce the slider bounds
+ * @param strictText?: boolean - whether to enforce the text bounds
+ * @param emphasis?: boolean - whether the field is emphasized
+ * @param size?: Size - the size of the field
+ * @param inactive?: boolean - whether the field is inactive
+ * @param disabled?: boolean - whether the field is disabled
+ * @param label?: string - the label of the field
+ * @param onLabelChange?: (label: string) => void - the function to call when the label changes
+ * @param onEmphasisChange?: (emphasis: boolean) => void - the function to call when the emphasis changes
+ * @param onFocus?: FocusEventHandler;
+ * @param onBlur?: FocusEventHandler;
+ */
+declare function InnerSliderNumberField({ value, onChange, min, max, visualMin, visualMax, units, color, strictText, strictSlider, emphasis, size, inactive, disabled, label, onLabelChange, onEmphasisChange, onBlur: onBlurExternal, onFocus: onFocusExternal, }: SliderNumberFieldProps): ReactNode;
+declare const SliderNumberField: react.MemoExoticComponent<typeof InnerSliderNumberField>;
+
+interface DropzoneProps<T extends BasicRowData> {
+    onDrop: (files: File[]) => void;
+    data: T[];
+    columns: ColumnDefinition<T>[];
+    rowClassName?: string;
+    headerClassName?: string;
+    multiple?: boolean;
+    accept?: Accept;
+    dropText?: string;
+    children?: ReactNode;
+    className?: string;
+}
+declare function Dropzone<T extends BasicRowData>({ onDrop, data, columns, rowClassName, headerClassName, multiple, accept, children, className, dropText, }: DropzoneProps<T>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Renders a scrollable area with optional header and footer.
+ *
+ * @example
+ * ```tsx
+ * <InnerScrollArea>
+ *   <div>Content goes here</div>
+ * </InnerScrollArea>
+ * ```
+ *
+ * @param children - The content to be rendered inside the scroll area.
+ * @param header - The optional header component to be displayed at the top of the scroll area.
+ * @param footer - The optional footer component to be displayed at the bottom of the scroll area.
+ * @param className - The optional CSS class name for the scroll area container.
+ * @param shrink - Determines whether the scroll area should shrink to fit its content.
+ * @returns The rendered scroll area component.
+ */
+declare function InnerScrollArea({ children, header, footer, className, style, shrink, orientation, }: {
+    children: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    shrink?: boolean;
+    orientation?: "vertical" | "horizontal" | "both";
+}): react_jsx_runtime.JSX.Element;
+declare const ScrollArea: react.MemoExoticComponent<typeof InnerScrollArea>;
+
+interface ChipProps {
+    value: string;
+    variant?: Variant;
+    size?: Size;
+    color?: string;
+    icon?: ReactNode;
+    onDelete?: MouseEventHandler<HTMLButtonElement>;
+}
+declare function Chip({ value, variant, size, color, icon, onDelete }: ChipProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * @param {string} label - The text to display in the option
+ * @param {string} value - The unique key to register and identify the option
+ * @param {boolean} disabled - Whether the option is disabled
+ * @param {string} color - The color of the option
+ * @param {ReactNode} icon - The icon to display in the option
+ */
+interface SelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    color?: string;
+    icon?: ReactNode;
+}
+/**
+ * @param {Variant} variant - The variant of the select (defines colors)
+ * @param {T} value - The value of the select
+ * @param {function} onChange - The function to call when the value changes
+ * @param {SelectOption[]} options - The options to display in the select
+ * @param {Size} size - The size of the select
+ * @param {string} label - The label of the select
+ */
+interface SelectProps<T extends string | string[]> {
+    variant?: Variant;
+    value?: T;
+    onChange: (value: T) => void;
+    options: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+        color?: string;
+        icon?: ReactNode;
+    }[];
+    size?: Size;
+    label?: string;
+}
+/**
+ * A select component that allows users to choose from a list of options
+ * @param {Variant} variant - The variant of the select (defines colors)
+ * @param {T} value - The value of the select
+ * @param {function} onChange - The function to call when the value changes
+ * @param {SelectOption[]} options - The options to display in the select
+ * @param {Size} size - The size of the select
+ * @param {string} label - The label of the select
+ */
+declare function Select<T extends string | string[]>({ value, onChange, options, variant, size, label, }: SelectProps<T>): react_jsx_runtime.JSX.Element;
+
+declare function SelectList<T extends string | string[]>({ value, onChange, options, variant, size, notFound, }: SelectProps<T> & {
+    notFound?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function FormBase({ children, title }: {
+    children: React.ReactNode;
+    title?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface IconRobotProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconRobot: react.ForwardRefExoticComponent<Omit<IconRobotProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconRobotPlusProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconRobotPlus: react.ForwardRefExoticComponent<Omit<IconRobotPlusProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconFileTypeAniProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconFileTypeAni: react.ForwardRefExoticComponent<Omit<IconFileTypeAniProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconFileTypeModProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconFileTypeMod: react.ForwardRefExoticComponent<Omit<IconFileTypeModProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconFileTypeVizijProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconFileTypeVizij: react.ForwardRefExoticComponent<Omit<IconFileTypeVizijProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconHomeProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconHome: react.ForwardRefExoticComponent<Omit<IconHomeProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconBoxProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconBox: react.ForwardRefExoticComponent<Omit<IconBoxProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconBoxPlusProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconBoxPlus: react.ForwardRefExoticComponent<Omit<IconBoxPlusProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const IconPlayerNextKey: react.ForwardRefExoticComponent<Omit<TablerIconsProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const IconPlayerEndBounds: react.ForwardRefExoticComponent<Omit<TablerIconsProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const IconPlayerPlay: react.ForwardRefExoticComponent<Omit<TablerIconsProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const IconPlayerPlay2: react.ForwardRefExoticComponent<Omit<TablerIconsProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconPlayPauseProps extends TablerIconsProps {
+    fillOpacity?: number;
+    dashed?: boolean;
+    center?: "play" | "pause";
+}
+declare const IconPlayPause: react.ForwardRefExoticComponent<Omit<IconPlayPauseProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const IconKeyOutline: react.ForwardRefExoticComponent<Omit<TablerIconsProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare const IconKeyOutlineDash: react.ForwardRefExoticComponent<Omit<TablerIconsProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconKeyProps extends TablerIconsProps {
+    fillOpacity?: number;
+    dashed?: boolean;
+    center?: "plus" | "minus";
+}
+declare const IconKey: react.ForwardRefExoticComponent<Omit<IconKeyProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconProjectProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconProject: react.ForwardRefExoticComponent<Omit<IconProjectProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconPreviewViewProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconPreviewView: react.ForwardRefExoticComponent<Omit<IconPreviewViewProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+declare function WorldElementIcon({ type }: {
+    type: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface IconFilterBoxProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconFilterBox: react.ForwardRefExoticComponent<Omit<IconFilterBoxProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface IconFilterXProps extends TablerIconsProps {
+    className?: string;
+}
+declare const IconFilterX: react.ForwardRefExoticComponent<Omit<IconFilterXProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+
+interface StaticIconProps {
+    children: ReactNode;
+    variant?: Variant;
+    color?: string;
+    size?: Size | "fit";
+    deemphasize?: boolean;
+    className?: string;
+}
+declare function StaticIcon({ children, variant, size, color, deemphasize, className, }: StaticIconProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonModalProps {
+    titleText: string;
+    onClick: () => void;
+}
+declare function ButtonModal({ titleText, onClick }: ButtonModalProps): JSX.Element;
+
+declare function CopyLinkButton({ link }: {
+    link: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function ThemeToggleButton(): react_jsx_runtime.JSX.Element;
+
+interface CallToActionButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant: Variant.Primary | Variant.Secondary | Variant.Tertiary;
+    size: Size.Lg | Size.Md | Size.Sm;
+}
+declare const CallToActionButton: react.ForwardRefExoticComponent<CallToActionButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Custom hook that returns the preferred system theme.
+ *
+ * @returns The preferred system theme, either `Theme.Dark` or `Theme.Light`.
+ */
+declare function useSystemThemePreference(): Theme.Dark | Theme.Light;
+
+declare function useDelayedBoolean(value: boolean, timeoutDuration: number): boolean;
+
+interface ThemeProviderProps {
+    children: ReactNode;
+}
+interface ThemeContextValue {
+    explicitTheme: Theme;
+    systemPreference: Theme;
+    setExplicitTheme: (theme: Theme) => void;
+    resolvedTheme: Theme.Dark | Theme.Light;
+}
+/**
+ * The context for managing the theme in the application.
+ */
+declare const ThemeContext: react.Context<ThemeContextValue>;
+
+declare function useTheme(): ThemeContextValue;
+
+/**
+ * A hook used to add a toast to the toast context. Must be used within a ToastManager context.
+ * @returns A function that adds a toast to the toast context.
+ */
+declare function useAddToast(): (data: ToastData) => void;
+
+/**
+ * Renders a tree of nodes.
+ *
+ * @param nodeList - The list of nodes to render.
+ * @param renderNode - The function that renders each individual node.
+ * @returns The rendered tree component.
+ */
+declare function NodeTree({ nodeList, renderNode, }: {
+    nodeList: any[];
+    renderNode: (node: any) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Custom hook to detect clicks outside a specified element.
+ * @param onClickAway - A callback function triggered when a click outside the element occurs.
+ * @param ref - An optional ref to be attached to the element you want to monitor.
+ */
+declare function useClickAway<T extends HTMLElement | null>(ref: React.RefObject<T>, onClickAway: (event: MouseEvent | TouchEvent) => void): void;
+
+interface MenuItemProps {
+    children: ReactNode;
+    variant: Variant;
+    title: ReactNode;
+}
+declare const MenuItem: react.ForwardRefExoticComponent<MenuItemProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SnippetProps {
+    text: string;
+    language?: string;
+    className?: string;
+}
+declare function Snippet({ text, language, className }: SnippetProps): react_jsx_runtime.JSX.Element;
+
+declare function getHeight(size?: Size): string;
+declare function getWidth(size?: Size): string;
+declare function getChipInsertSize(size?: Size): string;
+declare function getFontSize(size?: Size): string;
+declare function getBorder(variant?: Variant): string;
+declare function getHoverBorder(variant?: Variant): string;
+declare function getReversibleBgText(variant?: Variant, active?: boolean): string;
+declare function getItemSideStyle(variant?: Variant | "custom"): string;
+declare function getItemStyle(variant?: Variant | "custom"): string;
+declare function getSeparatorStyle(variant?: Variant | "custom"): string;
+declare function getChipColor(variant?: Variant | "custom"): string;
+declare function getOutline(variant?: Variant): string;
+declare function getBasicTextColor(variant?: Variant | "custom"): string;
+declare function getTooltipTextColor(variant?: Variant | "custom", invert?: boolean): string;
+declare function getBasicBgColor(variant?: Variant | "custom"): string;
+declare function getTextCaretColor(variant?: Variant | "custom"): string;
+declare function getHoverTextStyles(variant?: Variant): string;
+declare function getHoverButtonStyles(variant?: Variant): string;
+declare function getCheckedBgStyles(variant?: Variant): string;
+declare function getToggleButtonStyles(variant: Variant): string;
+declare function getGradient(variant?: Variant): string;
+declare function getInputStyles(flex?: boolean, subtle?: boolean, bold?: boolean, size?: Size, disabled?: boolean, className?: string, cursor?: string, constrainHeight?: boolean): string;
+
+export { Accordion, type AccordionProps, Anchor, type AnchorProps, Avatar, type AvatarProps, BasicNumberField, type BasicNumberFieldProps, type BasicRowData, Button, ButtonModal, type ButtonModalProps, type ButtonProps, CallToActionButton, type CallToActionButtonProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Collapse, type CollapseProps, CollapsibleContent, CollapsibleRoot, CollapsibleTrigger, ColorPickerInput, type ColorPickerInputProps, ColorPickerPopover, type ColorPickerPopoverProps, type ColumnDefinition, ContextMenu, type ContextMenuProps, CopyLinkButton, Dialog, type DialogProps, Dropdown, type DropdownProps, Dropzone, type DropzoneProps, EmailInput, type EmailInputProps, EmailsInput, type EmailsInputProps, FileInput, type FileInputProps, FormBase, IconBox, IconBoxPlus, type IconBoxPlusProps, type IconBoxProps, IconFileTypeAni, type IconFileTypeAniProps, IconFileTypeMod, type IconFileTypeModProps, IconFileTypeVizij, type IconFileTypeVizijProps, IconFilterBox, type IconFilterBoxProps, IconFilterX, type IconFilterXProps, IconHome, type IconHomeProps, IconKey, IconKeyOutline, IconKeyOutlineDash, type IconKeyProps, IconPlayPause, type IconPlayPauseProps, IconPlayerEndBounds, IconPlayerNextKey, IconPlayerPlay, IconPlayerPlay2, IconPreviewView, type IconPreviewViewProps, IconProject, type IconProjectProps, IconRobot, IconRobotPlus, type IconRobotPlusProps, type IconRobotProps, ImageButton, type ImageButtonProps, ImageInput, type ImageInputProps, InnerLayout, InnerScrollArea, type InputProps, Layout, type LayoutProps, Menu, MenuButton, type MenuButtonProps, MenuItem, type MenuItemProps, type MenuProps, Modal, type ModalProps, NestedCheckbox, type NestedCheckboxProps, NestedColorPicker, type NestedColorPickerProps, NestedItem, type NestedItemProps, NestedLabel, type NestedLabelProps, NestedMenu, type NestedMenuProps, NestedParent, NestedRadio, type NestedRadioProps, NestedSelect, type NestedSelectProps, NestedSeparator, type NestedSeparatorProps, NodeTree, NumberOrListInput, PasswordInput, type PasswordInputProps, Popover, type PopoverProps, Progress, type ProgressProps, ScrollArea, Search, type SearchProps, Select, SelectList, type SelectOption, type SelectProps, Separator, type SeparatorProps, Sidebar, type SidebarChild, type SidebarProps, Size, SliderNumberField, type SliderNumberFieldProps, Snippet, Spinner, StaticIcon, type StaticIconProps, Status, type StatusProps, type Step, StringsInput, type StringsInputProps, StyledArea, StyledInput, Switch, type SwitchProps, type TabChild, TableList, type TableListProps, Tabs, type TabsProps, TextArea, type TextAreaProps, TextField, type TextFieldProps, TextInput, type TextInputProps, Theme, ThemeContext, type ThemeContextValue, type ThemeProviderProps, ThemeToggleButton, TimeDisplay, TimeInput, type TimeInputProps, type ToastContainerProps, ToastContext, type ToastData, ToastManager, type ToastManagerProps, type ToastState, ToggleGroup, type ToggleGroupProps, ToggleSquare, type ToggleSquareProps, Tooltip, type TooltipProps, TrackedTooltip, type TrackedTooltipProps, Variant, VerticalStepper, type VerticalStepperProps, WorldElementIcon, getBasicBgColor, getBasicTextColor, getBorder, getCheckedBgStyles, getChipColor, getChipInsertSize, getFontSize, getGradient, getHeight, getHoverBorder, getHoverButtonStyles, getHoverTextStyles, getInputStyles, getItemSideStyle, getItemStyle, getOutline, getReversibleBgText, getSeparatorStyle, getTextCaretColor, getToggleButtonStyles, getTooltipTextColor, getWidth, stampToVisualTime, useAddToast, useClickAway, useDelayedBoolean, useMenu, useSystemThemePreference, useTheme, useTrackedTooltip };