@rebasepro/plugin-insights 0.0.1-canary.09e5ec5

package/dist/ui/src/components/IconButton.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export type IconButtonProps<C extends React.ElementType> = Omit<(C extends "button" ? React.ButtonHTMLAttributes<HTMLButtonElement> : React.ComponentProps<C>), "onClick"> & {
+    size?: "medium" | "small" | "smallest" | "large";
+    variant?: "ghost" | "filled";
+    shape?: "circular" | "square";
+    disabled?: boolean;
+    toggled?: boolean;
+    component?: C;
+    onClick?: React.MouseEventHandler<any>;
+    "aria-label"?: string;
+};
+export declare const IconButton: React.ComponentType<IconButtonProps<any>>;

package/dist/ui/src/components/InfoLabel.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function InfoLabel({ children, mode }: {
+    children: React.ReactNode;
+    mode?: "info" | "warn";
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/InputLabel.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+export type InputLabelProps = {
+    children?: React.ReactNode;
+    className?: string;
+    shrink?: boolean;
+} & React.LabelHTMLAttributes<HTMLLabelElement>;
+export declare const InputLabel: React.ForwardRefExoticComponent<{
+    children?: React.ReactNode;
+    className?: string;
+    shrink?: boolean;
+} & React.LabelHTMLAttributes<HTMLLabelElement> & React.RefAttributes<HTMLLabelElement>>;

package/dist/ui/src/components/Label.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & {
+    border?: boolean;
+    onClick?: React.MouseEventHandler<HTMLLabelElement>;
+} & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/ui/src/components/LoadingButton.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { ButtonProps } from "./Button";
+export type LoadingButtonProps<P extends React.ElementType> = ButtonProps<P> & {
+    startIcon?: React.ReactNode;
+    loading?: boolean;
+};
+export declare function LoadingButton<P extends React.ElementType = "button">({ children, loading, disabled, onClick, startIcon, ...props }: LoadingButtonProps<P>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Markdown.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export interface MarkdownProps {
+    source: string;
+    size?: "small" | "medium" | "large" | "xl" | "2xl";
+    className?: string;
+}
+/**
+ * @group Preview components
+ */
+export declare const Markdown: React.FunctionComponent<MarkdownProps>;

package/dist/ui/src/components/Menu.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+export type MenuProps = {
+    children: React.ReactNode;
+    trigger: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+    portalContainer?: HTMLElement | null;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+    className?: string;
+};
+declare const Menu: React.ForwardRefExoticComponent<MenuProps & React.RefAttributes<HTMLButtonElement>>;
+export { Menu };
+export type MenuItemProps = {
+    children: React.ReactNode;
+    dense?: boolean;
+    disabled?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+    className?: string;
+};
+export declare const MenuItem: React.MemoExoticComponent<({ children, dense, disabled, onClick, className }: MenuItemProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/ui/src/components/Menubar.d.ts

@@ -0,0 +1,80 @@
+import * as React from "react";
+export declare function Menubar({ children, onSelect, className }: {
+    children: React.ReactNode;
+    onSelect?: (event: React.SyntheticEvent) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarMenu({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarTrigger({ children, onSelect, className }: {
+    children: React.ReactNode;
+    onSelect?: (event: React.SyntheticEvent) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarPortal({ children, portalContainer }: {
+    children: React.ReactNode;
+    portalContainer?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarContent({ children, className, align, sideOffset, alignOffset, onSelect, ...rest }: {
+    children: React.ReactNode;
+    className?: string;
+    onSelect?: (event: React.SyntheticEvent) => void;
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+    alignOffset?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarItem({ children, leftPadding, className, disabled, onSelect, ...rest }: {
+    children: React.ReactNode;
+    onSelect?: (event: Event) => void;
+    leftPadding?: boolean;
+    className?: string;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarSeparator({ children, className, ...rest }: {
+    children?: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarSub({ children, ...rest }: {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarSubTrigger({ children, className, onSelect, ...rest }: {
+    children?: React.ReactNode;
+    onSelect?: (event: React.SyntheticEvent) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarSubContent({ children, alignOffset, className, onSelect, ...rest }: {
+    children?: React.ReactNode;
+    onSelect?: (event: React.SyntheticEvent) => void;
+    alignOffset?: number;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarCheckboxItem({ children, checked, onCheckedChange, className, onSelect, ...rest }: {
+    children?: React.ReactNode;
+    onSelect?: (event: Event) => void;
+    checked?: boolean;
+    onCheckedChange?: () => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarItemIndicator({ children, className, ...rest }: {
+    children?: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarRadioGroup({ children, className, value, onValueChange, onSelect, ...rest }: {
+    children?: React.ReactNode;
+    onSelect?: (event: React.SyntheticEvent) => void;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarRadioItem({ children, className, value, onSelect, ...rest }: {
+    children?: React.ReactNode;
+    onSelect?: (event: Event) => void;
+    value: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarShortcut({ children, className, ...rest }: {
+    children?: React.ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function MenubarSubTriggerIndicator(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/MultiSelect.d.ts

@@ -0,0 +1,48 @@
+import * as React from "react";
+import { ChangeEvent } from "react";
+export type MultiSelectValue = string | number | boolean;
+interface MultiSelectContextProps<T extends MultiSelectValue = string> {
+    fieldValue?: T[];
+    onItemClick: (v: T) => void;
+}
+export declare const MultiSelectContext: React.Context<MultiSelectContextProps<MultiSelectValue>>;
+/**
+ * Props for MultiSelect component
+ */
+interface MultiSelectProps<T extends MultiSelectValue = string> {
+    modalPopover?: boolean;
+    className?: string;
+    open?: boolean;
+    name?: string;
+    id?: string;
+    onOpenChange?: (open: boolean) => void;
+    value?: T[];
+    inputClassName?: string;
+    onChange?: React.EventHandler<ChangeEvent<HTMLSelectElement>>;
+    onValueChange?: (updatedValue: T[]) => void;
+    placeholder?: React.ReactNode;
+    size?: "smallest" | "small" | "medium" | "large";
+    useChips?: boolean;
+    label?: React.ReactNode | string;
+    disabled?: boolean;
+    error?: boolean;
+    position?: "item-aligned" | "popper";
+    endAdornment?: React.ReactNode;
+    multiple?: boolean;
+    includeSelectAll?: boolean;
+    includeClear?: boolean;
+    inputRef?: React.Ref<HTMLButtonElement>;
+    padding?: boolean;
+    invisible?: boolean;
+    children: React.ReactNode;
+    renderValues?: (values: T[]) => React.ReactNode;
+    portalContainer?: HTMLElement | null;
+}
+export declare const MultiSelect: React.ForwardRefExoticComponent<MultiSelectProps<string> & React.RefAttributes<HTMLButtonElement>>;
+export interface MultiSelectItemProps<T extends MultiSelectValue = string> {
+    value: T;
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare const MultiSelectItem: React.MemoExoticComponent<(<T extends MultiSelectValue = string>({ children, value, className }: MultiSelectItemProps<T>) => import("react/jsx-runtime").JSX.Element)>;
+export {};

package/dist/ui/src/components/Paper.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function Paper({ children, style, className }: {
+    children: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Popover.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export type PopoverSide = "top" | "right" | "bottom" | "left";
+export type PopoverAlign = "start" | "center" | "end";
+export interface PopoverProps {
+    trigger: React.ReactNode;
+    children: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: PopoverSide;
+    sideOffset?: number;
+    align?: PopoverAlign;
+    alignOffset?: number;
+    arrowPadding?: number;
+    sticky?: "partial" | "always";
+    hideWhenDetached?: boolean;
+    avoidCollisions?: boolean;
+    enabled?: boolean;
+    modal?: boolean;
+    className?: string;
+    portalContainer?: HTMLElement | null;
+    onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;
+}
+export declare function Popover({ trigger, children, open, onOpenChange, side, sideOffset, align, alignOffset, arrowPadding, sticky, hideWhenDetached, avoidCollisions, enabled, modal, portalContainer, className, onMouseEnter, onMouseLeave }: PopoverProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/RadioGroup.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+export interface RadioGroupProps {
+    id?: string;
+    children: React.ReactNode;
+    name?: string;
+    required?: boolean;
+    disabled?: boolean;
+    /**
+     * Whether keyboard navigation should loop around
+     * @defaultValue false
+     */
+    loop?: boolean;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?(value: string): void;
+    className?: string;
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+export interface RadioGroupItemProps {
+    id?: string;
+    value: string;
+    checked?: boolean;
+    required?: boolean;
+    className?: string;
+    disabled?: boolean;
+}
+declare const RadioGroupItem: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+export { RadioGroup, RadioGroupItem };

package/dist/ui/src/components/ResizablePanels.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+export type ResizablePanelsProps = {
+    firstPanel: React.ReactNode;
+    secondPanel: React.ReactNode;
+    /** Whether the first panel is visible (e.g. Sidebar) */
+    showFirstPanel?: boolean;
+    /** Whether the second panel is visible (e.g. Results) */
+    showSecondPanel?: boolean;
+    /** 0-100 representing the width/height of the first panel */
+    panelSizePercent: number;
+    onPanelSizeChange: (sizePercent: number) => void;
+    minPanelSizePx?: number;
+    orientation?: "horizontal" | "vertical";
+    animateLayout?: boolean;
+    className?: string;
+    stacked?: boolean;
+};
+export declare function ResizablePanels({ firstPanel, secondPanel, showFirstPanel, showSecondPanel, panelSizePercent, onPanelSizeChange, minPanelSizePx, orientation, animateLayout, className, stacked }: ResizablePanelsProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/SearchBar.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+interface SearchBarProps {
+    onClick?: () => void;
+    onTextSearch?: (searchString?: string) => void;
+    placeholder?: string;
+    expandable?: boolean;
+    /**
+     * Size of the search bar.
+     * - "small": 32px height (matches TextField small)
+     * - "medium": 44px height (matches TextField medium)
+     * @default "medium"
+     */
+    size?: "smallest" | "small" | "medium";
+    innerClassName?: string;
+    className?: string;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    inputRef?: React.Ref<HTMLInputElement>;
+}
+export declare function SearchBar({ onClick, onTextSearch, placeholder, expandable, size, innerClassName, className, autoFocus, disabled, loading, inputRef }: SearchBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/src/components/Select.d.ts

@@ -0,0 +1,43 @@
+import React, { ChangeEvent } from "react";
+export type SelectValue = string | number | boolean;
+export type SelectProps<T extends SelectValue = string> = {
+    open?: boolean;
+    name?: string;
+    fullWidth?: boolean;
+    id?: string;
+    onOpenChange?: (open: boolean) => void;
+    value?: T;
+    className?: string;
+    inputClassName?: string;
+    viewportClassName?: string;
+    onChange?: React.EventHandler<ChangeEvent<HTMLSelectElement>>;
+    onValueChange?: (updatedValue: T) => void;
+    placeholder?: React.ReactNode;
+    renderValue?: (value: T) => React.ReactNode;
+    size?: "smallest" | "small" | "medium" | "large";
+    label?: React.ReactNode | string;
+    disabled?: boolean;
+    error?: boolean;
+    position?: "item-aligned" | "popper";
+    endAdornment?: React.ReactNode;
+    inputRef?: React.Ref<HTMLButtonElement>;
+    padding?: boolean;
+    invisible?: boolean;
+    children?: React.ReactNode;
+    dataType?: "string" | "number" | "boolean";
+    portalContainer?: HTMLElement | null;
+};
+export declare const Select: React.ForwardRefExoticComponent<SelectProps<string> & React.RefAttributes<HTMLDivElement>>;
+export type SelectItemProps<T extends SelectValue = string> = {
+    value: T;
+    children?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+};
+export declare const SelectItem: React.MemoExoticComponent<(<T extends SelectValue = string>({ value, children, disabled, className }: SelectItemProps<T>) => import("react/jsx-runtime").JSX.Element)>;
+export type SelectGroupProps = {
+    label: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+};
+export declare const SelectGroup: React.NamedExoticComponent<SelectGroupProps>;

package/dist/ui/src/components/Separator.d.ts

@@ -0,0 +1,5 @@
+export declare function Separator({ orientation, decorative, className }: {
+    orientation: "horizontal" | "vertical";
+    decorative?: boolean;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Sheet.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+interface SheetProps {
+    children: React.ReactNode;
+    open: boolean;
+    title?: string;
+    modal?: boolean;
+    includeBackgroundOverlay?: boolean;
+    side?: "top" | "bottom" | "left" | "right";
+    darkBackground?: boolean;
+    transparent?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onPointerDownOutside?: (e: Event) => void;
+    onInteractOutside?: (e: Event) => void;
+    className?: string;
+    style?: React.CSSProperties;
+    overlayClassName?: string;
+    overlayZIndex?: string;
+    overlayStyle?: React.CSSProperties;
+    portalContainer?: HTMLElement | null;
+}
+export declare const Sheet: React.FC<SheetProps>;
+export {};

package/dist/ui/src/components/Skeleton.d.ts

@@ -0,0 +1,6 @@
+export type SkeletonProps = {
+    width?: number;
+    height?: number;
+    className?: string;
+};
+export declare function Skeleton({ width, height, className }: SkeletonProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Slider.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+export interface SliderProps {
+    className?: string;
+    name?: string;
+    disabled?: boolean;
+    orientation?: React.AriaAttributes["aria-orientation"];
+    dir?: "ltr" | "rtl";
+    min?: number;
+    max?: number;
+    step?: number;
+    minStepsBetweenThumbs?: number;
+    value?: number[];
+    defaultValue?: number[];
+    onValueChange?: (value: number[]) => void;
+    onValueCommit?: (value: number[]) => void;
+    inverted?: boolean;
+    form?: string;
+    size?: "small" | "regular";
+}
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

package/dist/ui/src/components/Table.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+export type TableProps = {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+} & React.TableHTMLAttributes<HTMLTableElement>;
+export declare const Table: React.MemoExoticComponent<({ children, className, style, ...rest }: TableProps) => import("react/jsx-runtime").JSX.Element>;
+export type TableBodyProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLTableSectionElement>;
+export declare const TableBody: React.MemoExoticComponent<({ children, className, ...rest }: TableBodyProps) => import("react/jsx-runtime").JSX.Element>;
+export type TableHeaderProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLTableSectionElement>;
+export declare const TableHeader: React.MemoExoticComponent<({ children, className, ...rest }: TableHeaderProps) => import("react/jsx-runtime").JSX.Element>;
+export type TableRowProps = {
+    children?: React.ReactNode;
+    className?: string;
+    onClick?: React.MouseEventHandler<any>;
+    style?: React.CSSProperties;
+} & React.HTMLAttributes<HTMLTableRowElement>;
+export declare const TableRow: React.MemoExoticComponent<({ children, className, onClick, style, ...rest }: TableRowProps) => import("react/jsx-runtime").JSX.Element>;
+export type TableCellProps = {
+    children?: React.ReactNode;
+    header?: boolean;
+    scope?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    align?: "left" | "center" | "right";
+    colspan?: number;
+} & React.HTMLAttributes<HTMLTableCellElement>;
+export declare const TableCell: React.MemoExoticComponent<({ children, header, scope, align, className, style, colspan, ...rest }: TableCellProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/ui/src/components/Tabs.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+export type TabVariant = "standard" | "boxy" | "pill";
+export type TabsProps = {
+    value: string;
+    children: React.ReactNode;
+    innerClassName?: string;
+    className?: string;
+    variant?: TabVariant;
+    onValueChange: (value: string) => void;
+};
+export declare function Tabs({ value, onValueChange, className, innerClassName, variant, children }: TabsProps): import("react/jsx-runtime").JSX.Element;
+export type TabProps = {
+    value: string;
+    className?: string;
+    innerClassName?: string;
+    children: React.ReactNode;
+    disabled?: boolean;
+};
+export declare function Tab({ value, className, innerClassName, children, disabled }: TabProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/TextField.d.ts

@@ -0,0 +1,58 @@
+import React from "react";
+export type InputType = "text" | "number" | "phone" | "email" | "password" | "search" | "url" | "date" | "time" | "datetime-local" | "month" | "week" | "color";
+export type TextFieldProps<T extends string | number> = {
+    type?: InputType;
+    value?: T;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    label?: React.ReactNode;
+    multiline?: boolean;
+    disabled?: boolean;
+    invisible?: boolean;
+    error?: boolean;
+    endAdornment?: React.ReactNode;
+    autoFocus?: boolean;
+    placeholder?: string;
+    size?: "smallest" | "small" | "medium" | "large";
+    className?: string;
+    style?: React.CSSProperties;
+    inputClassName?: string;
+    inputStyle?: React.CSSProperties;
+    inputRef?: React.ForwardedRef<any>;
+    /**
+     * Maximum number of rows to display.
+     */
+    maxRows?: number | string;
+    /**
+     * Minimum number of rows to display.
+     * @default 1
+     */
+    minRows?: number | string;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">;
+export declare const TextField: React.ForwardRefExoticComponent<{
+    type?: InputType;
+    value?: string | number | undefined;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    label?: React.ReactNode;
+    multiline?: boolean;
+    disabled?: boolean;
+    invisible?: boolean;
+    error?: boolean;
+    endAdornment?: React.ReactNode;
+    autoFocus?: boolean;
+    placeholder?: string;
+    size?: "smallest" | "small" | "medium" | "large";
+    className?: string;
+    style?: React.CSSProperties;
+    inputClassName?: string;
+    inputStyle?: React.CSSProperties;
+    inputRef?: React.ForwardedRef<any>;
+    /**
+     * Maximum number of rows to display.
+     */
+    maxRows?: number | string;
+    /**
+     * Minimum number of rows to display.
+     * @default 1
+     */
+    minRows?: number | string;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> & React.RefAttributes<HTMLDivElement>>;

package/dist/ui/src/components/TextareaAutosize.d.ts

@@ -0,0 +1,43 @@
+import * as React from "react";
+type State = {
+    outerHeightStyle: number;
+    overflow?: boolean | undefined;
+};
+export declare const TextareaAutosize: React.FC<TextareaAutosizeProps & {
+    ref?: React.ForwardedRef<Element>;
+}>;
+export type TextareaAutosizeProps = Omit<React.InputHTMLAttributes<HTMLTextAreaElement>, "onResize"> & {
+    className?: string;
+    shadowClassName?: string;
+    /**
+     * Maximum number of rows to display.
+     */
+    maxRows?: number | string;
+    /**
+     * Minimum number of rows to display.
+     * @default 1
+     */
+    minRows?: number | string;
+    /**
+     * @ignore
+     */
+    onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    /**
+     * @ignore
+     */
+    placeholder?: string;
+    /**
+     * @ignore
+     */
+    style?: object;
+    /**
+     * @ignore
+     */
+    value?: string[] | number | string;
+    sizeRef?: React.RefObject<HTMLDivElement>;
+    onScroll?: (event: React.UIEvent<HTMLTextAreaElement>) => void;
+    onResize?: (state: State) => void;
+    autoFocus?: boolean;
+    ignoreBoxSizing?: boolean;
+};
+export {};

package/dist/ui/src/components/ToggleButtonGroup.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+export type ToggleButtonOption<T extends string = string> = {
+    value: T;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+};
+export type ToggleButtonGroupProps<T extends string = string> = {
+    /**
+     * Currently selected value
+     */
+    value: T;
+    /**
+     * Callback when value changes
+     */
+    onValueChange: (value: T) => void;
+    /**
+     * Options to display
+     */
+    options: ToggleButtonOption<T>[];
+    /**
+     * Additional class names for the container
+     */
+    className?: string;
+};
+/**
+ * A toggle button group component for selecting one option from a set.
+ * Displays options as buttons in a horizontal row with active state styling.
+ */
+export declare function ToggleButtonGroup<T extends string = string>({ value, onValueChange, options, className }: ToggleButtonGroupProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/src/components/Tooltip.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+export type TooltipProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+    title?: string | React.ReactNode;
+    delayDuration?: number;
+    asChild?: boolean;
+    tooltipClassName?: string;
+    tooltipStyle?: React.CSSProperties;
+    children: React.ReactNode;
+    className?: string;
+    container?: HTMLElement;
+    style?: React.CSSProperties;
+};
+export declare const Tooltip: ({ open, defaultOpen, side, delayDuration, sideOffset, align, onOpenChange, title, tooltipClassName, tooltipStyle, children, asChild, container, className, style }: TooltipProps) => import("react/jsx-runtime").JSX.Element;