@noya-app/noya-designsystem 0.1.44 → 0.1.46

package/dist/index.d.mts

@@ -1,17 +1,20 @@
 import * as React from 'react';
-import React__default, { CSSProperties, ReactNode, AriaRole, KeyboardEventHandler, MouseEventHandler, PointerEventHandler, FocusEventHandler, InputHTMLAttributes, HTMLAttributes, ComponentProps, SyntheticEvent, ReactHTML } from 'react';
+import React__default, { ReactHTML, ReactNode, CSSProperties, HTMLAttributes, AriaRole, KeyboardEventHandler, MouseEventHandler, PointerEventHandler, FocusEventHandler, InputHTMLAttributes, LabelHTMLAttributes, ForwardedRef, ComponentProps, SyntheticEvent } from 'react';
 import { IItemScore } from 'vscode-fuzzy-scorer';
-import { Property } from 'csstype';
 import * as Icons from '@noya-app/noya-icons';
 export { Icons };
 import * as _noya_app_noya_geometry from '@noya-app/noya-geometry';
 import { Size } from '@noya-app/noya-geometry';
 import { useSortable } from '@dnd-kit/sortable';
+import { Property } from 'csstype';
+import * as _noya_app_noya_designsystem from '@noya-app/noya-designsystem';
+import { SelectableMenuItem as SelectableMenuItem$1 } from '@noya-app/noya-designsystem';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import * as RadixDropdownMenu from '@radix-ui/react-dropdown-menu';
 import { Sketch } from '@noya-app/noya-file-format';
 import * as _noya_app_noya_keymap from '@noya-app/noya-keymap';
 import { KeyModifiers, PlatformName } from '@noya-app/noya-keymap';
+import * as RadixContextMenu from '@radix-ui/react-context-menu';
 import { MultiplayerUser } from '@noya-app/noya-multiplayer-react';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
 import { SelectProps } from '@radix-ui/react-select';
@@ -49,8 +52,9 @@ type AnimatePresenceProps = {
      * "crossfade" - crossfade between the previous and next animation
      */
     mode?: "wait" | "crossfade";
+    className?: string;
 };
-declare const AnimatePresence: ({ children, duration, animationStyles, skipInitialAnimation, mode, }: AnimatePresenceProps) => React__default.JSX.Element;
+declare const AnimatePresence: ({ children, duration, animationStyles, skipInitialAnimation, mode, className, }: AnimatePresenceProps) => React__default.JSX.Element;
 
 type AvatarProps = {
     image?: string;
@@ -79,304 +83,522 @@ declare const AvatarStack: React__default.NamedExoticComponent<{
     className?: string;
 }>;
 
-type ButtonVariant = "normal" | "primary" | "secondary" | "secondaryBright" | "thin" | "floating" | "none";
-type ButtonSize = "small" | "normal" | "large" | "floating";
-interface ButtonRootProps {
-    id?: string;
-    className?: string;
-    style?: CSSProperties;
-    tabIndex?: number;
-    children: ReactNode;
-    active?: boolean;
-    disabled?: boolean;
-    variant?: ButtonVariant;
-    size?: ButtonSize;
-    tooltip?: ReactNode;
-    onClick?: (event: React__default.MouseEvent<HTMLButtonElement>) => void;
-    onPointerDown?: (event: React__default.PointerEvent<HTMLButtonElement>) => void;
-    contentStyle?: CSSProperties;
-    as?: React__default.ElementType;
-    htmlFor?: string;
-    href?: string;
-    target?: string;
-    rel?: string;
-}
-declare const Button: React__default.ForwardRefExoticComponent<ButtonRootProps & React__default.RefAttributes<HTMLButtonElement>>;
-
-interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
-    colorScheme?: "primary" | "secondary";
-}
-declare const Checkbox$1: React.MemoExoticComponent<React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>>;
-
-type ChipColorScheme = "primary" | "secondary" | "error";
-type ChipSize = "small" | "medium" | "large";
-type ChipVariant = "solid" | "outlined" | "ghost";
-interface ChipProps {
-    id?: string;
-    className?: string;
-    colorScheme?: ChipColorScheme;
-    variant?: ChipVariant;
-    size?: ChipSize;
-    children?: React__default.ReactNode;
-    clickable?: boolean;
-    deletable?: boolean;
-    addable?: boolean;
-    monospace?: boolean;
-    onDelete?: () => void;
-    onAdd?: () => void;
-    onClick?: () => void;
-    onHoverDeleteChange?: (hovering: boolean) => void;
-    style?: React__default.CSSProperties;
-    tabIndex?: number;
-}
-declare const Chip: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<ChipProps & React__default.RefAttributes<HTMLSpanElement>>>;
-
-declare function fuzzyScore({ item, query }: {
-    item: string;
-    query: string;
-}): IItemScore;
-type IScoredItem = IItemScore & {
-    index: number;
-};
-declare function fuzzyFilter({ items, query, scoreThreshold, }: {
-    items: string[];
-    query: string;
-    scoreThreshold?: number;
-}): IScoredItem[];
-type IToken = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'match';
-    text: string;
-};
-type MatchRange = {
-    start: number;
-    end: number;
+declare const config: {
+    content: string[];
+    corePlugins: {
+        preflight: false;
+    };
+    theme: {
+        extend: {
+            colors: {
+                "logo-fill": string;
+                "logo-highlight": string;
+                background: string;
+                text: string;
+                "text-muted": string;
+                "text-subtle": string;
+                "text-disabled": string;
+                "text-decorative-light": string;
+                "divider-subtle": string;
+                divider: string;
+                "divider-strong": string;
+                primary: string;
+                "primary-light": string;
+                "primary-pastel": string;
+                secondary: string;
+                "secondary-light": string;
+                "secondary-pastel": string;
+                "secondary-bright": string;
+                "input-background": string;
+                "input-background-light": string;
+                "code-background": string;
+                "code-background-dark": string;
+                "selected-background": string;
+                "breadcrumb-text": string;
+                "breadcrumb-text-hover": string;
+                "breadcrumb-icon": string;
+                "canvas-background": string;
+                "canvas-grid": string;
+                "sidebar-background": string;
+                "sidebar-background-transparent": string;
+                "popover-background": string;
+                "popover-divider": string;
+                "listview-raised-background": string;
+                "listview-editing-background": string;
+                "slider-thumb-background": string;
+                "slider-border": string;
+                "segmented-control-item": string;
+                mask: string;
+                "transparent-checker": string;
+                scrollbar: string;
+                "placeholder-dots": string;
+                "drag-outline": string;
+                "active-background": string;
+                "thumbnail-background": string;
+                "thumbnail-shadow": string;
+                "inline-code-text": string;
+                "inline-code-background": string;
+                "text-link": string;
+                "text-link-focused": string;
+                icon: string;
+                "icon-selected": string;
+                warning: string;
+                dot: string;
+                "row-highlight": string;
+                "table-row-background": string;
+                "chip-primary-bg": string;
+                "chip-secondary-bg": string;
+                "chip-error-bg": string;
+                "chip-default-bg": string;
+                "chip-primary-shadow": string;
+                "chip-secondary-shadow": string;
+                "chip-error-shadow": string;
+                "chip-default-shadow": string;
+                "floating-button": string;
+            };
+            fontFamily: {
+                sans: [string, string, string, string, string, string, string, string, string, string];
+                mono: [string, string, string, string, string];
+            };
+            fontSize: {
+                title: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+                subtitle: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+                heading1: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+                heading2: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+                heading3: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+                heading4: [string, {
+                    lineHeight: string;
+                }];
+                heading5: [string, {
+                    lineHeight: string;
+                }];
+                body: [string, {
+                    lineHeight: string;
+                }];
+                small: [string, {
+                    lineHeight: string;
+                }];
+                code: [string, {
+                    lineHeight: string;
+                }];
+                button: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+                label: [string, {
+                    lineHeight: string;
+                    letterSpacing: string;
+                }];
+            };
+            spacing: {
+                nano: string;
+                micro: string;
+                small: string;
+                medium: string;
+                large: string;
+                xlarge: string;
+                xxlarge: string;
+                "inset-top": string;
+                "sidebar-width": string;
+                "toolbar-height": string;
+                "toolbar-separator": string;
+                "inspector-h-separator": string;
+                "inspector-v-separator": string;
+                "dialog-padding": string;
+            };
+            keyframes: {
+                spin: {
+                    "0%": {
+                        transform: string;
+                    };
+                    "100%": {
+                        transform: string;
+                    };
+                };
+                shimmer: {
+                    "0%": {
+                        backgroundPosition: string;
+                    };
+                    "100%": {
+                        backgroundPosition: string;
+                    };
+                };
+            };
+            animation: {
+                spin: string;
+                shimmer: string;
+            };
+            zIndex: {
+                interactable: string;
+                label: string;
+                menu: string;
+            };
+        };
+    };
+    safelist: string[];
 };
-declare function fuzzyTokenize({ item, itemScore, }: {
-    item: string;
-    itemScore: IItemScore;
-}): IToken[];
 
-type ComboboxOption = {
-    type?: undefined;
-    id: string;
-    name: string;
-    icon?: ReactNode;
-    alwaysInclude?: boolean;
-};
-type ComboboxSectionHeader = {
-    type: "sectionHeader";
-    id: string;
-    name: string;
-    maxVisibleItems?: number;
-};
-type ComboboxItem = ComboboxOption | ComboboxSectionHeader;
-type InternalComboboxItem = (ComboboxOption & IScoredItem) | ComboboxSectionHeader;
-type ComboboxStateSnapshot = {
-    filter: string;
-    selectedIndex: number;
-    filteredItems: InternalComboboxItem[];
-    lastSubmittedValue: {
-        filter: string;
-        itemName: string;
+type Theme = (typeof config.theme)["extend"];
+type ThemeColor = keyof Theme["colors"];
+declare const cssVars: {
+    colors: {
+        logoFill: string;
+        logoHighlight: string;
+        background: string;
+        text: string;
+        textMuted: string;
+        textSubtle: string;
+        textDisabled: string;
+        textDecorativeLight: string;
+        dividerSubtle: string;
+        divider: string;
+        dividerStrong: string;
+        primary: string;
+        primaryLight: string;
+        primaryPastel: string;
+        secondary: string;
+        secondaryLight: string;
+        secondaryPastel: string;
+        secondaryBright: string;
+        inputBackground: string;
+        inputBackgroundLight: string;
+        codeBackground: string;
+        codeBackgroundDark: string;
+        selectedBackground: string;
+        breadcrumbText: string;
+        breadcrumbTextHover: string;
+        breadcrumbIcon: string;
+        canvasBackground: string;
+        canvasGrid: string;
+        sidebarBackground: string;
+        sidebarBackgroundTransparent: string;
+        popoverBackground: string;
+        popoverDivider: string;
+        listviewRaisedBackground: string;
+        listviewEditingBackground: string;
+        sliderThumbBackground: string;
+        sliderBorder: string;
+        segmentedControlItem: string;
+        mask: string;
+        transparentChecker: string;
+        scrollbar: string;
+        placeholderDots: string;
+        dragOutline: string;
+        activeBackground: string;
+        thumbnailBackground: string;
+        thumbnailShadow: string;
+        inlineCodeText: string;
+        inlineCodeBackground: string;
+        textLink: string;
+        textLinkFocused: string;
+        icon: string;
+        iconSelected: string;
+        warning: string;
+        dot: string;
+        rowHighlight: string;
+        tableRowBackground: string;
+        chipPrimaryBg: string;
+        chipSecondaryBg: string;
+        chipErrorBg: string;
+        chipDefaultBg: string;
+        chipPrimaryShadow: string;
+        chipSecondaryShadow: string;
+        chipErrorShadow: string;
+        chipDefaultShadow: string;
+        floatingButton: string;
+    };
+    fontFamily: {
+        sans: [string, string, string, string, string, string, string, string, string, string];
+        mono: [string, string, string, string, string];
+    };
+    fontSize: {
+        title: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+        subtitle: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+        heading1: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+        heading2: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+        heading3: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+        heading4: [string, {
+            lineHeight: string;
+        }];
+        heading5: [string, {
+            lineHeight: string;
+        }];
+        body: [string, {
+            lineHeight: string;
+        }];
+        small: [string, {
+            lineHeight: string;
+        }];
+        code: [string, {
+            lineHeight: string;
+        }];
+        button: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+        label: [string, {
+            lineHeight: string;
+            letterSpacing: string;
+        }];
+    };
+    spacing: {
+        nano: string;
+        micro: string;
+        small: string;
+        medium: string;
+        large: string;
+        xlarge: string;
+        xxlarge: string;
+        insetTop: string;
+        sidebarWidth: string;
+        toolbarHeight: string;
+        toolbarSeparator: string;
+        inspectorHSeparator: string;
+        inspectorVSeparator: string;
+        dialogPadding: string;
+    };
+    keyframes: {
+        spin: {
+            "0%": {
+                transform: string;
+            };
+            "100%": {
+                transform: string;
+            };
+        };
+        shimmer: {
+            "0%": {
+                backgroundPosition: string;
+            };
+            "100%": {
+                backgroundPosition: string;
+            };
+        };
+    };
+    animation: {
+        spin: string;
+        shimmer: string;
+    };
+    zIndex: {
+        interactable: string;
+        label: string;
+        menu: string;
     };
 };
-declare class ComboboxState {
-    private filter;
-    private selectedIndex;
-    private items;
-    private lastSubmittedValue;
-    private subscribers;
-    private version;
-    private _cachedSnapshot;
-    constructor(items: ComboboxItem[], initialValue: string, allowArbitraryValues: boolean);
-    subscribe: (listener: () => void) => (() => void);
-    private notifyChange;
-    private getFilteredItems;
-    getSnapshot: () => ComboboxStateSnapshot;
-    setItems(items: ComboboxItem[]): void;
-    setFilter(filter: string): void;
-    moveSelection(direction: "up" | "down"): void;
-    selectCurrentItem(item?: InternalComboboxItem): InternalComboboxItem | undefined;
-    restoreLastSubmittedValue(): void;
-    reset(newFilter?: string): void;
-    getSelectedItem(): InternalComboboxItem | undefined;
-    getTypeaheadValue(): string | undefined;
-    setSelectedIndex(index: number): void;
-    submitArbitraryFilter(filter: string): void;
-}
-declare function useComboboxState(state: ComboboxState): ComboboxStateSnapshot;
-
-type IconName = keyof typeof Icons;
 
-declare function renderIcon(iconName: Exclude<React.ReactNode, string> | IconName): React.ReactNode;
+type KebabToCamelCase<S extends string> = S extends `${infer First}-${infer Rest}` ? `${First}${Capitalize<KebabToCamelCase<Rest>>}` : S;
 
-declare const SEPARATOR_ITEM = "separator";
-type MenuItemRole = "undo" | "redo" | "cut" | "copy" | "paste" | "pasteAndMatchStyle" | "delete" | "selectAll" | "reload" | "forceReload" | "toggleDevTools" | "resetZoom" | "zoomIn" | "zoomOut" | "toggleSpellChecker" | "togglefullscreen" | "window" | "minimize" | "close" | "help" | "about" | "services" | "hide" | "hideOthers" | "unhide" | "quit" | "showSubstitutions" | "toggleSmartQuotes" | "toggleSmartDashes" | "toggleTextReplacement" | "startSpeaking" | "stopSpeaking" | "zoom" | "front" | "appMenu" | "fileMenu" | "editMenu" | "viewMenu" | "shareMenu" | "recentDocuments" | "toggleTabBar" | "selectNextTab" | "selectPreviousTab" | "mergeAllWindows" | "clearRecentDocuments" | "moveTabToNewWindow" | "windowMenu";
-type RegularMenuItem<T extends string> = {
-    value?: T;
-    title: ReactNode;
-    shortcut?: string;
-    checked?: boolean;
-    disabled?: boolean;
-    icon?: Exclude<ReactNode, string> | IconName;
-    items?: MenuItem<T>[];
-    role?: MenuItemRole;
+type Variant = "title" | "subtitle" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "body" | "small" | "button" | "code" | "label";
+declare const textStyles: Record<Variant, string>;
+type TextProps = {
+    as?: keyof ReactHTML;
+    href?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    variant: Variant;
+    color?: KebabToCamelCase<ThemeColor>;
+    children: ReactNode;
+    id?: string;
+    onClick?: () => void;
+    onDoubleClick?: () => void;
+    onKeyDown?: (event: React__default.KeyboardEvent<HTMLSpanElement>) => void;
+    tabIndex?: number;
 };
-type MenuItem<T extends string> = typeof SEPARATOR_ITEM | RegularMenuItem<T>;
-type ExtractMenuItemType<T> = T extends RegularMenuItem<infer U> ? U : never;
-declare function getKeyboardShortcutsForMenuItems<T extends string>(menuItems: MenuItem<T>[], onSelect: (type: T) => void): Record<string, () => void>;
-declare const KeyboardShortcut: React__default.NamedExoticComponent<{
-    shortcut: string;
-}>;
+declare const Text$1: React__default.ForwardRefExoticComponent<TextProps & React__default.RefAttributes<HTMLElement>>;
+type PresetProps = Omit<TextProps, "variant">;
+declare const Heading1: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Heading2: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Heading3: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Heading4: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Heading5: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Body: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Small: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
+declare const Italic: ({ children }: {
+    children: ReactNode;
+}) => React__default.JSX.Element;
 
-type Props$d = {
+type BreadcrumbTextProps = Omit<TextProps, "variant" | "whiteSpace" | "lineHeight" | "userSelect">;
+declare const BreadcrumbText: React__default.ForwardRefExoticComponent<BreadcrumbTextProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+type ButtonVariant = "normal" | "primary" | "secondary" | "secondaryBright" | "thin" | "floating" | "none";
+type ButtonSize = "small" | "normal" | "large" | "floating";
+interface ButtonRootProps {
     id?: string;
-    style?: any;
     className?: string;
-    type?: "text" | "search";
+    style?: CSSProperties;
+    tabIndex?: number;
+    children: ReactNode;
+    active?: boolean;
     disabled?: boolean;
-    value: string;
-    placeholder?: string;
-    role?: AriaRole;
-    name?: HTMLInputElement["name"];
-    onKeyDown?: KeyboardEventHandler;
-    onClick?: MouseEventHandler;
-    onDoubleClick?: MouseEventHandler;
-    onPointerDown?: PointerEventHandler;
-    onFocusCapture?: FocusEventHandler;
-    onFocusChange?: (isFocused: boolean) => void;
-    onBlur?: FocusEventHandler;
-} & Pick<InputHTMLAttributes<HTMLInputElement>, "autoComplete" | "autoCapitalize" | "autoCorrect" | "spellCheck" | "autoFocus">;
-type ReadOnlyProps = Props$d & {
-    readOnly: true;
-};
-type ControlledProps = Props$d & {
-    onChange: (value: string) => void;
-    onFocus?: FocusEventHandler;
-    onBlur?: FocusEventHandler;
-};
-type SubmittableProps = Props$d & {
-    onSubmit: (value: string) => void;
-    allowSubmittingWithSameValue?: boolean;
-    submitAutomaticallyAfterDelay?: number;
-};
-type TextInputProps = ReadOnlyProps | ControlledProps | SubmittableProps;
-
-type LabelPosition = "start" | "end";
-type InputFieldSize = "small" | "medium" | "large";
-interface InputFieldDropdownProps<T extends string> {
-    id?: string;
-    items: MenuItem<T>[];
-    onSelect: (value: T) => void;
-    children?: ReactNode;
-}
-type InputFieldInputProps = TextInputProps & {
-    textAlign?: Property.TextAlign;
-    variant?: "bare";
-};
-type InputFieldNumberInputProps = Omit<TextInputProps, "value" | "onChange" | "onKeyDown" | "onSubmit" | "readOnly"> & {
-    value: number | undefined;
-    onNudge?: (value: number) => void;
-    variant?: "bare";
-    onFocus?: FocusEventHandler;
-    onBlur?: FocusEventHandler;
-    readOnly?: boolean;
-} & ({
-    onChange: (value: number) => void;
-} | {
-    onSubmit: (value: number) => void;
-});
-declare function InputFieldNumberInput(props: InputFieldNumberInputProps): React__default.JSX.Element;
-interface InputFieldRootProps {
-    id?: string;
-    children?: ReactNode;
-    width?: number;
-    /** @default end */
-    labelPosition?: LabelPosition;
-    labelSize?: number;
-    /** @default medium */
-    size?: InputFieldSize;
-    renderPopoverContent?: (options: {
-        width: number;
-    }) => ReactNode;
-    /**
-     * if there is a popover, this is the offset from the trigger
-     * @default 3
-     */
-    sideOffset?: number;
-    onFocusChange?: (isFocused: boolean) => void;
-    style?: React__default.CSSProperties;
-    className?: string;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    tooltip?: ReactNode;
+    onClick?: (event: React__default.MouseEvent<HTMLButtonElement>) => void;
+    onPointerDown?: (event: React__default.PointerEvent<HTMLButtonElement>) => void;
+    contentStyle?: CSSProperties;
+    as?: React__default.ElementType;
+    htmlFor?: string;
+    href?: string;
+    target?: string;
+    rel?: string;
 }
-declare function InputFieldRoot({ id, children, width, labelPosition, sideOffset, labelSize, size, renderPopoverContent, onFocusChange, style, className, }: InputFieldRootProps): React__default.JSX.Element;
-declare namespace InputField {
-    const Root: React__default.MemoExoticComponent<typeof InputFieldRoot>;
-    const Input: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<InputFieldInputProps & React__default.RefAttributes<HTMLInputElement>>>;
-    const Typeahead: React__default.MemoExoticComponent<(props: {
-        prefix: string;
-        value: string;
-        isFocused: boolean;
-    }) => React__default.JSX.Element>;
-    const NumberInput: React__default.MemoExoticComponent<typeof InputFieldNumberInput>;
-    const DropdownMenu: <T extends string>(props: InputFieldDropdownProps<T>) => React__default.ReactElement | null;
-    const Button: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<React__default.ButtonHTMLAttributes<HTMLButtonElement> & {
-        buttonClassName?: string;
-        variant?: "floating" | "normal";
-    } & React__default.RefAttributes<HTMLButtonElement>>>;
-    const Label: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<React__default.LabelHTMLAttributes<HTMLLabelElement> & React__default.RefAttributes<HTMLLabelElement>>>;
-    const PrimitiveElement: ({ readOnly, disabled, className, style, ...props }: {
-        readOnly?: boolean;
-        disabled?: boolean;
-    } & React__default.DetailedHTMLProps<React__default.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>) => React__default.JSX.Element;
+declare const Button: React__default.ForwardRefExoticComponent<ButtonRootProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
+    colorScheme?: "primary" | "secondary";
 }
+declare const Checkbox$1: React.MemoExoticComponent<React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>>;
 
-type BaseComboboxProps = {
+type ChipColorScheme = "primary" | "secondary" | "error";
+type ChipSize = "small" | "medium" | "large";
+type ChipVariant = "solid" | "outlined" | "ghost";
+interface ChipProps {
     id?: string;
-    loading?: boolean;
-    placeholder?: string;
-    items: ComboboxItem[];
-    onFocus?: (event: React__default.FocusEvent<HTMLInputElement>) => void;
-    onDeleteWhenEmpty?: () => void;
-    size?: InputFieldSize;
-    style?: React__default.CSSProperties;
     className?: string;
-    label?: React__default.ReactNode;
+    colorScheme?: ChipColorScheme;
+    variant?: ChipVariant;
+    size?: ChipSize;
     children?: React__default.ReactNode;
-    hideMenuWhenEmptyValue?: boolean;
-    readOnly?: boolean;
-    tabBehavior?: "autocomplete" | "select";
-    openMenuBehavior?: "showAllItems" | "showFilteredItems";
+    clickable?: boolean;
+    deletable?: boolean;
+    addable?: boolean;
+    monospace?: boolean;
+    onDelete?: () => void;
+    onAdd?: () => void;
+    onClick?: () => void;
+    onHoverDeleteChange?: (hovering: boolean) => void;
+    style?: React__default.CSSProperties;
+    tabIndex?: number;
+}
+declare const Chip: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<ChipProps & React__default.RefAttributes<HTMLSpanElement>>>;
+
+type GridViewSize = "xxs" | "xs" | "small" | "medium" | "large" | "xl";
+declare const getGridSize: (size: GridViewSize) => {
+    minColumnWidth: string;
+    gap: number;
 };
-type StringModeOnlyProps = {
-    mode: "string";
-    value?: string;
-    onChange?: (value: string) => void;
-    onSelectItem?: (value: string) => void;
-    onBlur?: (didSubmit: boolean, value: string) => void;
-    onHoverItem?: (value: string | undefined) => void;
-    allowArbitraryValues?: boolean;
+declare const Grid: <T, M extends string = string>(props: CollectionProps<T, M> & {
+    ref?: React__default.ForwardedRef<CollectionRef>;
+} & React__default.RefAttributes<CollectionRef>) => React__default.ReactElement | null;
+
+declare function fuzzyScore({ item, query }: {
+    item: string;
+    query: string;
+}): IItemScore;
+type IScoredItem = IItemScore & {
+    index: number;
 };
-type StringModeProps = BaseComboboxProps & StringModeOnlyProps;
-type OptionModeOnlyProps = {
-    mode?: "option";
-    value?: ComboboxOption;
-    onChange?: (value: ComboboxOption) => void;
-    onSelectItem?: (value: ComboboxOption) => void;
-    onBlur?: (didSubmit: boolean, value: ComboboxOption) => void;
-    onHoverItem?: (value: ComboboxOption | undefined) => void;
-    allowArbitraryValues?: false;
+declare function fuzzyFilter({ items, query, scoreThreshold, }: {
+    items: string[];
+    query: string;
+    scoreThreshold?: number;
+}): IScoredItem[];
+type IToken = {
+    type: "text";
+    text: string;
+} | {
+    type: "match";
+    text: string;
 };
-type OptionModeProps = BaseComboboxProps & OptionModeOnlyProps;
-type ComboboxProps = StringModeProps | OptionModeProps;
-interface ComboboxRef {
-    focus(): void;
-    setValue(value: string | ComboboxOption): void;
-    selectAllInputText(): void;
-}
-declare const Combobox: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<ComboboxProps & React__default.RefAttributes<ComboboxRef>>>;
+type MatchRange = {
+    start: number;
+    end: number;
+};
+declare function fuzzyTokenize({ item, itemScore, }: {
+    item: string;
+    itemScore: IItemScore;
+}): IToken[];
+
+type IconName = keyof typeof Icons;
+
+declare function renderIcon(iconName: Exclude<React.ReactNode, string> | IconName): React.ReactNode;
+
+type MenuItemRole = "undo" | "redo" | "cut" | "copy" | "paste" | "pasteAndMatchStyle" | "delete" | "selectAll" | "reload" | "forceReload" | "toggleDevTools" | "resetZoom" | "zoomIn" | "zoomOut" | "toggleSpellChecker" | "togglefullscreen" | "window" | "minimize" | "close" | "help" | "about" | "services" | "hide" | "hideOthers" | "unhide" | "quit" | "showSubstitutions" | "toggleSmartQuotes" | "toggleSmartDashes" | "toggleTextReplacement" | "startSpeaking" | "stopSpeaking" | "zoom" | "front" | "appMenu" | "fileMenu" | "editMenu" | "viewMenu" | "shareMenu" | "recentDocuments" | "toggleTabBar" | "selectNextTab" | "selectPreviousTab" | "mergeAllWindows" | "clearRecentDocuments" | "moveTabToNewWindow" | "windowMenu";
+type SeparatorItem = {
+    type: "separator";
+};
+type BaseMenuItem = {
+    checked?: boolean;
+    disabled?: boolean;
+    icon?: Exclude<ReactNode, string> | IconName;
+    role?: MenuItemRole;
+    alwaysInclude?: boolean;
+    title: NonNullable<ReactNode>;
+};
+type SectionHeaderMenuItem = {
+    type: "sectionHeader";
+    id: string;
+    title: ReactNode;
+    maxVisibleItems?: number;
+    variant?: "normal" | "label";
+};
+type SelectableMenuItem<T extends string> = BaseMenuItem & {
+    type?: undefined;
+    shortcut?: string;
+    value: T;
+};
+type SubMenuItem<T extends string> = BaseMenuItem & {
+    type: "submenu";
+    items: MenuItem<T>[];
+    id: string;
+};
+type NonSelectableMenuItem<T extends string> = SeparatorItem | SectionHeaderMenuItem | SubMenuItem<T>;
+type MenuItem<T extends string> = SeparatorItem | SelectableMenuItem<T> | SectionHeaderMenuItem | SubMenuItem<T>;
+type ScoredSelectableMenuItem<T extends string> = SelectableMenuItem<T> & IScoredItem;
+type ScoredMenuItem<T extends string> = ScoredSelectableMenuItem<T> | SectionHeaderMenuItem;
+type ExtractMenuItemType<T> = T extends SelectableMenuItem<infer U> ? U : never;
+declare const isSelectableMenuItem: <T extends string>(item: MenuItem<T>) => item is SelectableMenuItem<T>;
+declare const isNonSelectableMenuItem: <T extends string>(item: MenuItem<T>) => item is NonSelectableMenuItem<T>;
+declare const isMenuItemSectionHeader: (item: MenuItem<string>) => item is SectionHeaderMenuItem;
+declare const isSelectableMenuItemWithScore: (item: MenuItem<string>) => item is ScoredSelectableMenuItem<string>;
+declare const CHECKBOX_WIDTH = 16;
+declare const CHECKBOX_RIGHT_INSET = 8;
+declare const styles: {
+    separatorStyle: string;
+    itemStyle: ({ disabled }: {
+        disabled?: boolean;
+    }) => string;
+    itemIndicatorStyle: string;
+    contentStyle: string;
+};
+declare function getKeyboardShortcutsForMenuItems<T extends string>(menuItems: MenuItem<T>[], onSelect: (type: T) => void): Record<string, () => void>;
+declare const KeyboardShortcut: React__default.NamedExoticComponent<{
+    shortcut: string;
+}>;
+declare const SectionHeader$1: React__default.NamedExoticComponent<Omit<SectionHeaderMenuItem, "type" | "maxVisibleItems"> & {
+    isFirst?: boolean;
+    indented?: boolean;
+}>;
 
 type RelativeDropPosition = "above" | "below" | "inside";
 type DropValidator = (sourceIndex: number, destinationIndex: number, position: RelativeDropPosition) => boolean;
@@ -426,8 +648,9 @@ interface EditableRowProps {
     onSubmitEditing: (value: string) => void;
     autoFocus: boolean;
     placeholder?: string;
+    className?: string;
 }
-declare function ListViewEditableRowTitle({ value, onSubmitEditing, autoFocus, placeholder, }: EditableRowProps): React__default.JSX.Element;
+declare function ListViewEditableRowTitle({ value, onSubmitEditing, autoFocus, placeholder, className, }: EditableRowProps): React__default.JSX.Element;
 interface ListViewClickInfo {
     shiftKey: boolean;
     altKey: boolean;
@@ -437,6 +660,7 @@ interface ListViewClickInfo {
 interface ListViewRowProps<MenuItemType extends string = string> {
     id?: string;
     tabIndex?: number;
+    role?: string;
     selected?: boolean;
     /** @default 0 */
     depth?: number;
@@ -484,12 +708,16 @@ type RenderProps<T> = {
     sortable?: boolean;
     virtualized?: Size;
 };
-type ListViewVariant = "normal" | "padded" | "bare";
+type ListViewVariant = "normal" | "bare";
 type ListViewSectionHeaderVariant = "normal" | "label";
 type ListViewRootProps = {
     id?: string;
     className?: string;
     style?: CSSProperties;
+    role?: string;
+    "aria-labelledby"?: string;
+    "aria-orientation"?: "vertical" | "horizontal";
+    "aria-multiselectable"?: boolean;
     onPress?: () => void;
     scrollable?: boolean;
     expandable?: boolean;
@@ -502,6 +730,11 @@ type ListViewRootProps = {
     divider?: boolean;
     gap?: number;
     colorScheme?: ListColorScheme;
+    containerRef?: React__default.RefObject<HTMLDivElement>;
+    onDragOver?: React__default.DragEventHandler<HTMLDivElement>;
+    onDragEnter?: React__default.DragEventHandler<HTMLDivElement>;
+    onDragLeave?: React__default.DragEventHandler<HTMLDivElement>;
+    onDrop?: React__default.DragEventHandler<HTMLDivElement>;
 };
 declare namespace ListView {
     const RowTitle: React__default.MemoExoticComponent<({ className, children, ...props }: {
@@ -524,38 +757,304 @@ declare namespace ListView {
     } & React__default.RefAttributes<HTMLDivElement>>;
     const rowHeight = 31;
     const sectionHeaderLabelHeight = 27;
-    const calculateHeight: (items: number, headerCount: number, headerVariant: ListViewSectionHeaderVariant) => number;
+    const calculateHeight: ({ menuItemsCount, sectionHeaderCount, }: {
+        menuItemsCount: number;
+        sectionHeaderCount: number;
+    }) => number;
     const normalizeDestinationIndex: (index: number, position: "above" | "below") => number;
 }
 
-interface ComboboxMenuProps {
-    items: InternalComboboxItem[];
-    selectedIndex: number;
-    onSelectItem: (item: InternalComboboxItem) => void;
-    onHoverIndex: (index: number) => void;
-    listSize: Size;
-    style?: React__default.CSSProperties;
+type CollectionViewType = "grid" | "list";
+type CollectionRef = {
+    editName: (id: string) => void;
+};
+interface CollectionProps<T, M extends string = string> {
+    className?: string;
+    items: T[];
+    getId: (item: T) => string;
+    getName: (item: T) => string;
+    getExpanded?: (item: T) => boolean | undefined;
+    /**
+     * Whether directories should be expandable.
+     * @default true
+     */
+    expandable?: boolean;
+    /**
+     *  Whether to allow renaming files
+     * @default true
+     */
+    renamable?: boolean;
+    menuItems?: MenuItem<M>[];
+    onSelectMenuItem?: (action: M, selectedItems: T[]) => void;
+    onRename?: (item: T, newName: string) => void;
+    renderThumbnail?: (item: T, selected: boolean) => React__default.ReactNode;
+    renderAction?: (item: T, selected: boolean) => React__default.ReactNode;
+    renderDetail?: (item: T, selected: boolean) => React__default.ReactNode;
+    /** Callback when selection changes. If not provided, selection will be disabled. */
+    onSelectionChange?: (selectedItemIds: string[], event?: ListView.ClickInfo) => void;
+    scrollable?: boolean;
+    itemRoleDescription?: string;
+    /** Position of the detail content. Defaults to 'end'. */
+    detailPosition?: "end" | "below";
+    /** Size of the list items. Defaults to 'medium'. */
+    size?: GridViewSize;
+    /** For testing: Override the hover state with a specific item ID */
+    testHoveredId?: string;
+    /** For testing: Override the renaming state with a specific item ID */
+    testRenamingId?: string;
+    setExpanded?: (item: T, expanded: boolean) => void;
+    acceptsDrop?: ListViewRootProps["acceptsDrop"];
+    onMoveItem?: ListViewRootProps["onMoveItem"];
+    getDepth?: (item: T) => number;
+    onFilesDrop?: (event: React__default.DragEvent<Element>) => void;
+    getRenamable?: (item: T) => boolean;
+    /** Currently selected file IDs */
+    selectedIds?: string[];
+    viewType?: CollectionViewType;
+    onDoubleClickItem?: (itemId: string) => void;
 }
-declare const ComboboxMenu: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<ComboboxMenuProps & React__default.RefAttributes<IVirtualizedList>>>;
+declare const Collection: <T, M extends string = string>(props: CollectionProps<T, M> & React__default.RefAttributes<CollectionRef>) => React__default.ReactElement | null;
 
-interface MenuItemProps<T extends string> {
-    value?: T;
-    children: ReactNode;
-    onSelect: (value: T) => void;
-    checked: boolean;
-    disabled: boolean;
-    indented: boolean;
-    shortcut?: string;
-    icon?: ReactNode;
-    items?: MenuItem<T>[];
+type Props$d = {
+    id?: string;
+    style?: any;
+    className?: string;
+    type?: "text" | "search";
+    disabled?: boolean;
+    value: string;
+    placeholder?: string;
+    role?: AriaRole;
+    name?: HTMLInputElement["name"];
+    onKeyDown?: KeyboardEventHandler;
+    onClick?: MouseEventHandler;
+    onDoubleClick?: MouseEventHandler;
+    onPointerDown?: PointerEventHandler;
+    onFocusCapture?: FocusEventHandler;
+    onFocusChange?: (isFocused: boolean) => void;
+    onBlur?: FocusEventHandler;
+} & Pick<InputHTMLAttributes<HTMLInputElement>, "autoComplete" | "autoCapitalize" | "autoCorrect" | "spellCheck" | "autoFocus">;
+type ReadOnlyProps = Props$d & {
+    readOnly: true;
+};
+type ControlledProps = Props$d & {
+    onChange: (value: string) => void;
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+};
+type SubmittableProps = Props$d & {
+    onSubmit: (value: string) => void;
+    allowSubmittingWithSameValue?: boolean;
+    submitAutomaticallyAfterDelay?: number;
+};
+type TextInputProps = ReadOnlyProps | ControlledProps | SubmittableProps;
+
+type LabelPosition = "inset" | "start" | "end" | "above";
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    /** @default start */
+    position?: Exclude<LabelPosition, "inset">;
 }
-interface MenuProps<T extends string> {
-    children: ReactNode;
+type InsetLabelProps = {
+    /** @default medium */
+    size?: InputFieldSize;
+    /** when used with an InputField.Root and label position is inset, it will add padding to the right of the label to account for the button */
+    buttonSize?: number;
+} & LabelHTMLAttributes<HTMLLabelElement>;
+declare const insetLabelTextStyles = "font-sans text-label uppercase text-text-disabled leading-[19px] font-bold text-[60%] truncate pointer-events-none text-right";
+declare const insetLabelStyles = "flex items-center absolute top-0 bottom-0 z-label";
+declare const InsetLabel: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<{
+    /** @default medium */
+    size?: InputFieldSize;
+    /** when used with an InputField.Root and label position is inset, it will add padding to the right of the label to account for the button */
+    buttonSize?: number;
+} & React__default.LabelHTMLAttributes<HTMLLabelElement> & React__default.RefAttributes<HTMLLabelElement>>>;
+declare const Label: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<LabelProps & React__default.RefAttributes<HTMLLabelElement>>>;
+
+type InputFieldSize = "small" | "medium" | "large";
+type InputFieldContextValue = {
+    labelSize?: number;
+    buttonSize?: number;
+    /** @default medium */
+    size: InputFieldSize;
+    isFocused: boolean;
+    onFocusChange: (isFocused: boolean) => void;
+    inputRef?: ForwardedRef<HTMLInputElement>;
+    setInputRef?: (ref: ForwardedRef<HTMLInputElement>) => void;
+    setLabelWidth?: (width: number) => void;
+    setButtonWidth?: (width: number) => void;
+    id?: string;
+    label?: ReactNode;
+    labelPosition?: LabelPosition;
+};
+declare const useInputFieldContext: () => InputFieldContextValue;
+declare const getFieldSpacing: ({ buttonSize, labelSize, variant, }: {
+    buttonSize?: number;
+    labelSize?: number;
+    variant?: InputFieldVariant;
+}) => {
+    paddingLeft: string;
+    paddingRight: string;
+};
+interface InputFieldDropdownProps<T extends string> {
+    id?: string;
     items: MenuItem<T>[];
     onSelect: (value: T) => void;
-    isNested?: boolean;
-    shouldBindKeyboardShortcuts?: boolean;
-    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+type InputFieldVariant = "normal" | "bare";
+type InputFieldInputProps = TextInputProps & {
+    textAlign?: Property.TextAlign;
+    variant?: "bare";
+};
+type InputFieldNumberInputProps = Omit<TextInputProps, "value" | "onChange" | "onKeyDown" | "onSubmit" | "readOnly"> & {
+    value: number | undefined;
+    onNudge?: (value: number) => void;
+    variant?: "bare";
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+    readOnly?: boolean;
+    className?: string;
+} & ({
+    onChange: (value: number) => void;
+} | {
+    onSubmit: (value: number) => void;
+});
+declare function InputFieldNumberInput(props: InputFieldNumberInputProps): React__default.JSX.Element;
+interface InputFieldRootProps {
+    id?: string;
+    children?: ReactNode;
+    width?: number;
+    labelSize?: number;
+    /** @default medium */
+    size?: InputFieldSize;
+    renderPopoverContent?: (options: {
+        width: number;
+    }) => ReactNode;
+    /**
+     * if there is a popover, this is the offset from the trigger
+     * @default 3
+     */
+    sideOffset?: number;
+    onFocusChange?: (isFocused: boolean) => void;
+    style?: React__default.CSSProperties;
+    className?: string;
+}
+declare function InputFieldRoot({ id: idProp, children, width, sideOffset, labelSize, size, renderPopoverContent, onFocusChange, style, className, }: InputFieldRootProps): React__default.JSX.Element;
+type InputFieldProps = InputFieldRootProps & InputFieldInputProps;
+declare const InputField: React__default.ForwardRefExoticComponent<InputFieldProps & React__default.RefAttributes<HTMLInputElement>> & {
+    readonly Root: React__default.MemoExoticComponent<typeof InputFieldRoot>;
+    readonly Input: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<InputFieldInputProps & React__default.RefAttributes<HTMLInputElement>>>;
+    readonly Typeahead: React__default.MemoExoticComponent<(props: {
+        prefix: string;
+        value: string;
+        isFocused: boolean;
+    }) => React__default.JSX.Element>;
+    readonly NumberInput: React__default.MemoExoticComponent<typeof InputFieldNumberInput>;
+    readonly DropdownMenu: <T extends string>(props: InputFieldDropdownProps<T>) => React__default.ReactElement | null;
+    readonly Button: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<React__default.ButtonHTMLAttributes<HTMLButtonElement> & ButtonRootProps & {
+        buttonClassName?: string;
+        variant?: "floating" | "normal";
+    } & React__default.RefAttributes<HTMLButtonElement>>>;
+    readonly Label: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<React__default.LabelHTMLAttributes<HTMLLabelElement> & React__default.RefAttributes<HTMLLabelElement>>>;
+    readonly PrimitiveElement: ({ readOnly, disabled, className, style, ...props }: {
+        readOnly?: boolean;
+        disabled?: boolean;
+    } & React__default.DetailedHTMLProps<React__default.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>) => React__default.JSX.Element;
+};
+
+type BaseComboboxProps<T extends string> = {
+    id?: string;
+    loading?: boolean;
+    placeholder?: string;
+    items: MenuItem<T>[];
+    onFocus?: (event: React__default.FocusEvent<HTMLInputElement>) => void;
+    onDeleteWhenEmpty?: () => void;
+    size?: InputFieldSize;
+    style?: React__default.CSSProperties;
+    className?: string;
+    label?: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    hideMenuWhenEmptyValue?: boolean;
+    readOnly?: boolean;
+    tabBehavior?: "autocomplete" | "select";
+    openMenuBehavior?: "showAllItems" | "showFilteredItems";
+};
+type StringModeOnlyProps = {
+    mode: "string";
+    value?: string;
+    onChange?: (value: string) => void;
+    onSelectItem?: (value: string) => void;
+    onBlur?: (didSubmit: boolean, value: string) => void;
+    onHoverItem?: (value: string | undefined) => void;
+    allowArbitraryValues?: boolean;
+};
+type StringModeProps<T extends string> = BaseComboboxProps<T> & StringModeOnlyProps;
+type OptionModeOnlyProps<T extends string> = {
+    mode?: "option";
+    value?: SelectableMenuItem<T>;
+    onChange?: (value: SelectableMenuItem<T>) => void;
+    onSelectItem?: (value: SelectableMenuItem<T>) => void;
+    onBlur?: (didSubmit: boolean, value: SelectableMenuItem<T>) => void;
+    onHoverItem?: (value: SelectableMenuItem<T> | undefined) => void;
+    allowArbitraryValues?: false;
+};
+type OptionModeProps<T extends string> = BaseComboboxProps<T> & OptionModeOnlyProps<T>;
+type ComboboxProps<T extends string> = StringModeProps<T> | OptionModeProps<T>;
+interface ComboboxRef<T extends string> {
+    focus(): void;
+    setValue(value: string | SelectableMenuItem<T>): void;
+    selectAllInputText(): void;
+}
+declare const Combobox: <T extends string>(props: ComboboxProps<T> & React__default.RefAttributes<ComboboxRef<T>>) => React__default.ReactElement | null;
+
+interface ComboboxMenuProps<T extends string> {
+    items: ScoredMenuItem<T>[];
+    selectedIndex: number;
+    onSelectItem: (item: ScoredMenuItem<T>) => void;
+    onHoverIndex: (index: number) => void;
+    listSize: Size;
+    style?: React__default.CSSProperties;
+}
+declare const ComboboxMenu: <T extends string>(props: ComboboxMenuProps<T> & React__default.RefAttributes<IVirtualizedList>) => React__default.ReactElement | null;
+
+interface ISearchCompletionMenu {
+    focus: () => void;
+}
+declare const SearchCompletionMenu: React__default.ForwardRefExoticComponent<{
+    onSelect: (item: SelectableMenuItem$1<string>) => void;
+    onHover?: (item: SelectableMenuItem$1<string>) => void;
+    onClose: () => void;
+    items: SelectableMenuItem$1<string>[];
+    width?: number;
+} & React__default.RefAttributes<ISearchCompletionMenu>>;
+
+declare const CommandPalette: React__default.NamedExoticComponent<{
+    showCommandPalette: boolean;
+    setShowCommandPalette: (value: boolean) => void;
+} & Pick<{
+    onSelect: (item: _noya_app_noya_designsystem.SelectableMenuItem<string>) => void;
+    onHover?: (item: _noya_app_noya_designsystem.SelectableMenuItem<string>) => void;
+    onClose: () => void;
+    items: _noya_app_noya_designsystem.SelectableMenuItem<string>[];
+    width?: number;
+} & React__default.RefAttributes<ISearchCompletionMenu>, "onSelect" | "items" | "onHover">>;
+
+interface MenuItemProps<T extends string> {
+    value?: T;
+    children: ReactNode;
+    onSelect: (value: T) => void;
+    checked: boolean;
+    disabled: boolean;
+    indented: boolean;
+    shortcut?: string;
+    icon?: ReactNode;
+    items?: MenuItem<T>[];
+}
+interface MenuProps<T extends string> {
+    children: ReactNode;
+    items: MenuItem<T>[];
+    onSelect: (value: T) => void;
+    shouldBindKeyboardShortcuts?: boolean;
+    onOpenChange?: (open: boolean) => void;
 }
 declare const ContextMenu: <T extends string>(props: MenuProps<T>) => React__default.ReactElement | null;
 
@@ -597,12 +1096,69 @@ declare const DraggableMenuButton: <T extends string>(props: {
     isVisible?: boolean;
 }) => React__default.ReactElement | null;
 
+type DropdownRootProps<T extends string> = MenuProps<T> & {
+    open?: boolean;
+    onCloseAutoFocus?: React__default.EventHandler<SyntheticEvent<unknown>>;
+    emptyState?: React__default.ReactNode;
+    contentStyle?: React__default.CSSProperties;
+} & Pick<ComponentProps<typeof RadixDropdownMenu.Content>, "side" | "sideOffset" | "align" | "alignOffset" | "collisionPadding">;
 declare const DropdownMenu: <T extends string>(props: MenuProps<T> & {
     open?: boolean;
     onCloseAutoFocus?: React__default.EventHandler<SyntheticEvent<unknown>>;
     emptyState?: React__default.ReactNode;
+    contentStyle?: React__default.CSSProperties;
 } & Pick<RadixDropdownMenu.DropdownMenuContentProps & React__default.RefAttributes<HTMLDivElement>, "align" | "side" | "sideOffset" | "alignOffset" | "collisionPadding"> & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
 
+type RenderPreviewProps = {
+    children: string;
+    onClick: () => void;
+    ref: React__default.Ref<HTMLElement & HTMLAnchorElement & HTMLSpanElement>;
+    tabIndex: number;
+    onKeyDown: (e: React__default.KeyboardEvent) => void;
+    style?: React__default.CSSProperties;
+    className?: string;
+};
+type Props$b = {
+    value: string;
+    children?: (props: RenderPreviewProps) => React__default.ReactNode;
+    placeholder?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    style?: React__default.CSSProperties;
+    textStyle?: React__default.CSSProperties;
+    className?: string;
+    id?: string;
+    disabled?: boolean;
+    focused?: boolean;
+    textClassName?: string;
+    readOnly?: boolean;
+    onBlur?: () => void;
+    /**
+     * If true, will render an unfocused input. This should only be used for visual regression tests.
+     */
+    testFocused?: boolean;
+};
+interface EditableTextRef {
+    startEditing: () => void;
+}
+declare const EditableText: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<Props$b & React__default.RefAttributes<EditableTextRef>>>;
+
+type FadeDirection = "left" | "right" | "top" | "bottom";
+type FadeProps = {
+    children: ReactNode;
+    direction?: FadeDirection;
+    width?: number;
+    height?: number;
+    className?: string;
+    zIndex?: number;
+    /**
+     * @default "front"
+     * If "back", the fade will be positioned behind the children
+     */
+    position?: "front" | "back";
+};
+declare const Fade: ({ children, direction, width, height, className, zIndex, position, }: FadeProps) => React__default.JSX.Element;
+
 declare const SUPPORTED_IMAGE_UPLOAD_TYPES: ("image/png" | "image/jpeg" | "image/webp" | "image/svg+xml" | "application/pdf")[];
 declare const SUPPORTED_CANVAS_UPLOAD_TYPES: ("" | "image/png" | "image/jpeg" | "image/webp" | "image/svg+xml" | "application/pdf")[];
 type SupportedImageUploadType = (typeof SUPPORTED_IMAGE_UPLOAD_TYPES)[number];
@@ -614,21 +1170,21 @@ type SketchPattern = {
     patternTileScale: number;
 };
 
-interface Props$b {
+interface Props$a {
     id?: string;
     value?: Sketch.Color | Sketch.Gradient | SketchPattern;
 }
-declare const FillInputField: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<Props$b & React__default.RefAttributes<HTMLButtonElement>>>;
+declare const FillInputField: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<Props$a & React__default.RefAttributes<HTMLButtonElement>>>;
 
 declare const PatternPreviewBackground: React.NamedExoticComponent<{
     fillType: Sketch.PatternFillType;
     tileScale: number;
     imageRef: string;
 }>;
-interface Props$a {
+interface Props$9 {
     value?: Sketch.Color | Sketch.Gradient | SketchPattern;
 }
-declare const FillPreviewBackground: React.NamedExoticComponent<Props$a>;
+declare const FillPreviewBackground: React.NamedExoticComponent<Props$9>;
 
 interface FloatingWindowProps {
     title?: string;
@@ -649,7 +1205,7 @@ interface FloatingWindowProps {
 }
 declare const FloatingWindow: React__default.FC<FloatingWindowProps>;
 
-interface Props$9 {
+interface Props$8 {
     value: Sketch.GradientStop[];
     selectedStop: number;
     onChangeColor: (color: Sketch.Color) => void;
@@ -658,561 +1214,259 @@ interface Props$9 {
     onDelete: () => void;
     onSelectStop: (index: number) => void;
 }
-declare const GradientPicker: React.NamedExoticComponent<Props$9>;
+declare const GradientPicker: React.NamedExoticComponent<Props$8>;
 
-type GridViewSize = "xxs" | "xs" | "small" | "medium" | "large" | "xl";
 interface ItemProps<MenuItemType extends string = string> {
     id: string;
     title?: ReactNode;
     subtitle?: ReactNode;
     loading?: boolean;
     selected?: boolean;
-    onClick?: (event: React__default.MouseEvent) => void;
-    onPress?: (options: KeyModifiers) => void;
-    onDoubleClick?: () => void;
-    onHoverChange?: (isHovering: boolean) => void;
-    children?: ReactNode;
-    menuItems?: MenuItem<MenuItemType>[];
-    onSelectMenuItem?: (value: MenuItemType) => void;
-    onContextMenu?: () => void;
-    style?: CSSProperties;
-}
-type GridViewContextValue = {
-    size: GridViewSize;
-    textPosition: "overlay" | "below" | "toolip";
-    bordered: boolean;
-    disabled: boolean;
-};
-interface GridViewRootProps extends Partial<GridViewContextValue> {
-    children: ReactNode;
-    onClick?: () => void;
-    scrollable?: boolean;
-}
-declare function GridViewRoot({ size, children, scrollable, onClick, textPosition, bordered, disabled, }: GridViewRootProps): React__default.JSX.Element;
-declare function GridViewSection({ children, className, }: {
-    children?: ReactNode;
-    className?: string;
-}): React__default.JSX.Element;
-declare function GridViewSectionHeader({ title }: {
-    title: string;
-}): React__default.JSX.Element;
-declare namespace GridView {
-    const Root: React__default.MemoExoticComponent<typeof GridViewRoot>;
-    const Item: React__default.MemoExoticComponent<(<MenuItemType extends string>(props: ItemProps<MenuItemType> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null)>;
-    const Section: React__default.MemoExoticComponent<typeof GridViewSection>;
-    const SectionHeader: React__default.MemoExoticComponent<typeof GridViewSectionHeader>;
-}
-
-declare const IconButton: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<ButtonRootProps, "size" | "children" | "variant" | "flex"> & {
-    iconName: IconName;
-    className?: string;
-    style?: React.CSSProperties;
-    selected?: boolean;
-    color?: string;
-    size?: number;
-} & React.RefAttributes<HTMLButtonElement>>>;
-
-declare const InspectorContainer: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<{
-    header?: React__default.ReactNode;
-    children?: React__default.ReactNode;
-    fallback?: React__default.ReactNode;
-    showDividers?: boolean;
-    id?: string;
-    className?: string;
-    style?: React__default.CSSProperties;
-} & React__default.RefAttributes<HTMLDivElement>>>;
-
-interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
-}
-declare const Label: React.MemoExoticComponent<React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>>;
-
-interface ContainerProps {
-    children: React.ReactNode;
-    renderLabel: (provided: {
-        id: string;
-        index: number;
-    }) => React.ReactNode;
-}
-declare const LabeledElementView: React.NamedExoticComponent<ContainerProps>;
-
-type MessageProps = {
-    role: "user" | "assistant" | "system" | "data";
-    children?: React__default.ReactNode;
-    user?: MultiplayerUser;
-    /** @default 27 */
-    avatarSize?: number;
-};
-declare const Message: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<MessageProps & React__default.RefAttributes<HTMLDivElement>>>;
-
-type PopoverVariant = "normal" | "large";
-interface Props$8 extends Pick<ComponentProps<(typeof PopoverPrimitive)["Content"]>, "onOpenAutoFocus" | "onCloseAutoFocus" | "onPointerDownOutside" | "onInteractOutside" | "onFocusOutside" | "side"> {
-    children: React__default.ReactNode;
-    trigger: React__default.ReactNode;
-    variant?: PopoverVariant;
-    closable?: boolean;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    sideOffset?: number;
-    onClickClose?: () => void;
-    showArrow?: boolean;
-}
-declare function Popover({ children, trigger, variant, closable, open, side, sideOffset, showArrow, onOpenChange, onOpenAutoFocus, onCloseAutoFocus, onPointerDownOutside, onInteractOutside, onFocusOutside, onClickClose, }: Props$8): React__default.JSX.Element;
-
-type ProgressVariant = "normal" | "warning" | "primary" | "secondary";
-declare function Progress({ value, variant, className, }: {
-    value: number;
-    variant?: ProgressVariant;
-    className?: string;
-}): React.JSX.Element;
-
-interface Props$7 {
-    children?: React.ReactNode | ((scrollElementRef: HTMLDivElement) => React.ReactNode);
-}
-declare const ScrollArea: React.NamedExoticComponent<Props$7>;
-
-type SegmentedControlColorScheme = "primary" | "secondary";
-interface SegmentedControlProps<T extends string> {
-    id?: string;
-    value?: T;
-    onValueChange?: (value: T) => void;
-    /** @default primary */
-    colorScheme?: SegmentedControlColorScheme;
-    allowEmpty?: boolean;
-    separator?: boolean;
-    items: SegmentedControlItemProps<T>[];
-    className?: string;
-    style?: React__default.CSSProperties;
-}
-type SegmentedControlItemProps<T extends string> = {
-    title?: ReactNode;
-    className?: string;
-    style?: React__default.CSSProperties;
-    tooltip?: ReactNode;
-} & Pick<RegularMenuItem<T>, "value" | "disabled" | "icon" | "role">;
-declare const SegmentedControl: React__default.MemoExoticComponent<(<T extends string>({ id, value, onValueChange, colorScheme, allowEmpty, items, separator, className, style, }: SegmentedControlProps<T>) => React__default.JSX.Element)>;
-
-type Props$6<T extends string> = {
-    id?: string;
-    style?: React__default.CSSProperties;
-    className?: string;
-    menuItems: MenuItem<T>[];
-    value: T;
-    onSelect?: (value: T) => void;
-    placeholder?: string;
-    disabled?: boolean;
-    readOnly?: boolean;
-    label?: React__default.ReactNode;
-    onFocus?: FocusEventHandler;
-    onBlur?: FocusEventHandler;
-    contentStyle?: React__default.CSSProperties;
-} & Pick<SelectProps, "open" | "onOpenChange">;
-declare const labelTextStyles = "font-sans text-label uppercase text-text-disabled leading-[19px] font-bold text-[60%]";
-declare const SelectMenu: <T extends string = string>(props: Props$6<T>) => React__default.ReactElement | null;
-
-type ColorScheme = "primary" | "secondary";
-interface Props$5 {
-    id?: string;
-    style?: React__default.CSSProperties;
-    className?: string;
-    value: number;
-    onValueChange: (value: number) => void;
-    min: number;
-    max: number;
-    step?: number;
-    colorScheme?: ColorScheme;
-    label?: React__default.ReactNode;
-    onFocus?: FocusEventHandler;
-    onBlur?: FocusEventHandler;
-    readOnly?: boolean;
-}
-declare const Slider: React__default.NamedExoticComponent<Props$5>;
-
-interface Props$4 {
-    size?: number | string;
-    inline?: boolean;
-}
-declare namespace Spacer {
-    const Vertical: React.ForwardRefExoticComponent<Props$4 & React.RefAttributes<HTMLSpanElement>>;
-    const Horizontal: React.ForwardRefExoticComponent<Props$4 & React.RefAttributes<HTMLSpanElement>>;
-}
-
-type SwitchColorScheme = "primary" | "secondary";
-interface Props$3 {
-    id?: string;
-    value: boolean;
-    onChange: (value: boolean) => void;
-    /** @default normal */
-    colorScheme?: SwitchColorScheme;
-    disabled?: boolean;
-    onFocus?: React.FocusEventHandler;
-    onBlur?: React.FocusEventHandler;
-    className?: string;
-    style?: React.CSSProperties;
-}
-declare const Switch: ({ id, value, onChange, colorScheme, disabled, onFocus, onBlur, style, className, }: Props$3) => React.JSX.Element;
-
-declare const config: {
-    content: string[];
-    corePlugins: {
-        preflight: false;
-    };
-    theme: {
-        extend: {
-            colors: {
-                "logo-fill": string;
-                "logo-highlight": string;
-                background: string;
-                text: string;
-                "text-muted": string;
-                "text-subtle": string;
-                "text-disabled": string;
-                "text-decorative-light": string;
-                "divider-subtle": string;
-                divider: string;
-                "divider-strong": string;
-                primary: string;
-                "primary-light": string;
-                "primary-pastel": string;
-                secondary: string;
-                "secondary-light": string;
-                "secondary-pastel": string;
-                "secondary-bright": string;
-                "input-background": string;
-                "input-background-light": string;
-                "code-background": string;
-                "code-background-dark": string;
-                "selected-background": string;
-                "breadcrumb-text": string;
-                "breadcrumb-text-hover": string;
-                "breadcrumb-icon": string;
-                "canvas-background": string;
-                "canvas-grid": string;
-                "sidebar-background": string;
-                "sidebar-background-transparent": string;
-                "popover-background": string;
-                "popover-divider": string;
-                "listview-raised-background": string;
-                "listview-editing-background": string;
-                "slider-thumb-background": string;
-                "slider-border": string;
-                "segmented-control-item": string;
-                mask: string;
-                "transparent-checker": string;
-                scrollbar: string;
-                "placeholder-dots": string;
-                "drag-outline": string;
-                "active-background": string;
-                "thumbnail-background": string;
-                "thumbnail-shadow": string;
-                "inline-code-text": string;
-                "inline-code-background": string;
-                "text-link": string;
-                "text-link-focused": string;
-                icon: string;
-                "icon-selected": string;
-                warning: string;
-                dot: string;
-                "row-highlight": string;
-                "table-row-background": string;
-                "chip-primary-bg": string;
-                "chip-secondary-bg": string;
-                "chip-error-bg": string;
-                "chip-default-bg": string;
-                "chip-primary-shadow": string;
-                "chip-secondary-shadow": string;
-                "chip-error-shadow": string;
-                "chip-default-shadow": string;
-                "floating-button": string;
-            };
-            fontFamily: {
-                sans: [string, string, string, string, string, string, string, string, string, string];
-                mono: [string, string, string, string, string];
-            };
-            fontSize: {
-                title: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-                subtitle: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-                heading1: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-                heading2: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-                heading3: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-                heading4: [string, {
-                    lineHeight: string;
-                }];
-                heading5: [string, {
-                    lineHeight: string;
-                }];
-                body: [string, {
-                    lineHeight: string;
-                }];
-                small: [string, {
-                    lineHeight: string;
-                }];
-                code: [string, {
-                    lineHeight: string;
-                }];
-                button: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-                label: [string, {
-                    lineHeight: string;
-                    letterSpacing: string;
-                }];
-            };
-            spacing: {
-                nano: string;
-                micro: string;
-                small: string;
-                medium: string;
-                large: string;
-                xlarge: string;
-                xxlarge: string;
-                "inset-top": string;
-                "sidebar-width": string;
-                "toolbar-height": string;
-                "toolbar-separator": string;
-                "inspector-h-separator": string;
-                "inspector-v-separator": string;
-                "dialog-padding": string;
-            };
-            keyframes: {
-                spin: {
-                    "0%": {
-                        transform: string;
-                    };
-                    "100%": {
-                        transform: string;
-                    };
-                };
-                shimmer: {
-                    "0%": {
-                        backgroundPosition: string;
-                    };
-                    "100%": {
-                        backgroundPosition: string;
-                    };
-                };
-            };
-            animation: {
-                spin: string;
-                shimmer: string;
-            };
-            zIndex: {
-                interactable: string;
-                label: string;
-                menu: string;
-            };
-        };
-    };
-    safelist: string[];
-};
-
-type Theme = (typeof config.theme)["extend"];
-type ThemeColor = keyof Theme["colors"];
-declare const cssVars: {
-    colors: {
-        logoFill: string;
-        logoHighlight: string;
-        background: string;
-        text: string;
-        textMuted: string;
-        textSubtle: string;
-        textDisabled: string;
-        textDecorativeLight: string;
-        dividerSubtle: string;
-        divider: string;
-        dividerStrong: string;
-        primary: string;
-        primaryLight: string;
-        primaryPastel: string;
-        secondary: string;
-        secondaryLight: string;
-        secondaryPastel: string;
-        secondaryBright: string;
-        inputBackground: string;
-        inputBackgroundLight: string;
-        codeBackground: string;
-        codeBackgroundDark: string;
-        selectedBackground: string;
-        breadcrumbText: string;
-        breadcrumbTextHover: string;
-        breadcrumbIcon: string;
-        canvasBackground: string;
-        canvasGrid: string;
-        sidebarBackground: string;
-        sidebarBackgroundTransparent: string;
-        popoverBackground: string;
-        popoverDivider: string;
-        listviewRaisedBackground: string;
-        listviewEditingBackground: string;
-        sliderThumbBackground: string;
-        sliderBorder: string;
-        segmentedControlItem: string;
-        mask: string;
-        transparentChecker: string;
-        scrollbar: string;
-        placeholderDots: string;
-        dragOutline: string;
-        activeBackground: string;
-        thumbnailBackground: string;
-        thumbnailShadow: string;
-        inlineCodeText: string;
-        inlineCodeBackground: string;
-        textLink: string;
-        textLinkFocused: string;
-        icon: string;
-        iconSelected: string;
-        warning: string;
-        dot: string;
-        rowHighlight: string;
-        tableRowBackground: string;
-        chipPrimaryBg: string;
-        chipSecondaryBg: string;
-        chipErrorBg: string;
-        chipDefaultBg: string;
-        chipPrimaryShadow: string;
-        chipSecondaryShadow: string;
-        chipErrorShadow: string;
-        chipDefaultShadow: string;
-        floatingButton: string;
-    };
-    fontFamily: {
-        sans: [string, string, string, string, string, string, string, string, string, string];
-        mono: [string, string, string, string, string];
-    };
-    fontSize: {
-        title: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-        subtitle: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-        heading1: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-        heading2: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-        heading3: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-        heading4: [string, {
-            lineHeight: string;
-        }];
-        heading5: [string, {
-            lineHeight: string;
-        }];
-        body: [string, {
-            lineHeight: string;
-        }];
-        small: [string, {
-            lineHeight: string;
-        }];
-        code: [string, {
-            lineHeight: string;
-        }];
-        button: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-        label: [string, {
-            lineHeight: string;
-            letterSpacing: string;
-        }];
-    };
-    spacing: {
-        nano: string;
-        micro: string;
-        small: string;
-        medium: string;
-        large: string;
-        xlarge: string;
-        xxlarge: string;
-        insetTop: string;
-        sidebarWidth: string;
-        toolbarHeight: string;
-        toolbarSeparator: string;
-        inspectorHSeparator: string;
-        inspectorVSeparator: string;
-        dialogPadding: string;
-    };
-    keyframes: {
-        spin: {
-            "0%": {
-                transform: string;
-            };
-            "100%": {
-                transform: string;
-            };
-        };
-        shimmer: {
-            "0%": {
-                backgroundPosition: string;
-            };
-            "100%": {
-                backgroundPosition: string;
-            };
-        };
-    };
-    animation: {
-        spin: string;
-        shimmer: string;
-    };
-    zIndex: {
-        interactable: string;
-        label: string;
-        menu: string;
-    };
+    onClick?: (event: React__default.MouseEvent) => void;
+    onSelect?: (options: KeyModifiers) => void;
+    onDoubleClick?: () => void;
+    onHoverChange?: (isHovering: boolean) => void;
+    children?: ReactNode;
+    menuItems?: MenuItem<MenuItemType>[];
+    onSelectMenuItem?: (value: MenuItemType) => void;
+    onContextMenu?: () => void;
+    onMenuOpenChange?: (open: boolean) => void;
+    style?: CSSProperties;
+    action?: ReactNode;
+    testHoveredId?: string;
+    onKeyDown?: (event: React__default.KeyboardEvent) => void;
+    hovered?: boolean;
+}
+type GridViewContextValue = {
+    minColumnWidth: string;
+    textPosition: "overlay" | "below" | "toolip";
+    bordered: boolean;
+    disabled: boolean;
+    gap: number;
 };
+interface GridViewRootProps extends Partial<GridViewContextValue> {
+    children: ReactNode;
+    onClick?: () => void;
+    scrollable?: boolean;
+    className?: string;
+}
+declare function GridViewRoot({ minColumnWidth, gap, children, scrollable, onClick, textPosition, bordered, disabled, className, }: GridViewRootProps): React__default.JSX.Element;
+declare function GridViewSection({ children, className, }: {
+    children?: ReactNode;
+    className?: string;
+}): React__default.JSX.Element;
+declare function GridViewSectionHeader({ title }: {
+    title: string;
+}): React__default.JSX.Element;
+declare namespace GridView {
+    const Root: React__default.MemoExoticComponent<typeof GridViewRoot>;
+    const Item: <MenuItemType extends string>(props: ItemProps<MenuItemType> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+    const Section: React__default.MemoExoticComponent<typeof GridViewSection>;
+    const SectionHeader: React__default.MemoExoticComponent<typeof GridViewSectionHeader>;
+}
 
-type KebabToCamelCase<S extends string> = S extends `${infer First}-${infer Rest}` ? `${First}${Capitalize<KebabToCamelCase<Rest>>}` : S;
+declare const IconButton: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<ButtonRootProps, "size" | "children" | "variant" | "flex"> & {
+    iconName: IconName;
+    className?: string;
+    style?: React.CSSProperties;
+    selected?: boolean;
+    color?: string;
+    size?: number;
+} & React.RefAttributes<HTMLButtonElement>>>;
 
-type Variant = "title" | "subtitle" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "body" | "small" | "button" | "code" | "label";
-declare const textStyles: Record<Variant, string>;
-type TextProps = {
-    as?: keyof ReactHTML;
-    href?: string;
+declare const InspectorContainer: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<{
+    header?: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    fallback?: React__default.ReactNode;
+    showDividers?: boolean;
+    id?: string;
     className?: string;
     style?: React__default.CSSProperties;
-    variant: Variant;
-    color?: KebabToCamelCase<ThemeColor>;
-    children: ReactNode;
-    onClick?: () => void;
-    onDoubleClick?: () => void;
-    onKeyDown?: (event: React__default.KeyboardEvent<HTMLSpanElement>) => void;
-    tabIndex?: number;
+} & React__default.RefAttributes<HTMLDivElement>>>;
+
+type MenuSeparatorComponent = React__default.FC<{
+    className?: string;
+}>;
+type MenuItemTextComponent = React__default.FC<{
+    children?: React__default.ReactNode;
+}>;
+type MenuItemComponent = React__default.ForwardRefExoticComponent<React__default.RefAttributes<HTMLDivElement> & React__default.PropsWithoutRef<{
+    className?: string;
+    disabled?: boolean;
+    children?: React__default.ReactNode;
+    value: string;
+    onSelect?: (event: any) => void;
+}>>;
+type MenuCheckboxItemComponent = React__default.FC<{
+    checked?: boolean | "indeterminate";
+    disabled?: boolean;
+    onSelect?: (event: any) => void;
+    className?: string;
+    children?: React__default.ReactNode;
+}>;
+type MenuItemIndicatorComponent = React__default.FC<{
+    className?: string;
+    children?: React__default.ReactNode;
+}>;
+type MenuComponents = {
+    Separator: MenuSeparatorComponent;
+    ItemText: MenuItemTextComponent;
+    Item: MenuItemComponent;
+    CheckboxItem?: MenuCheckboxItemComponent;
+    ItemIndicator?: MenuItemIndicatorComponent;
+    Sub?: typeof RadixDropdownMenu.Sub | typeof RadixContextMenu.Sub;
+    SubTrigger?: typeof RadixDropdownMenu.SubTrigger | typeof RadixContextMenu.SubTrigger;
+    SubContent?: typeof RadixDropdownMenu.SubContent | typeof RadixContextMenu.SubContent;
+    Portal?: typeof RadixDropdownMenu.Portal | typeof RadixContextMenu.Portal;
 };
-declare const Text$1: React__default.ForwardRefExoticComponent<TextProps & React__default.RefAttributes<HTMLElement>>;
-type PresetProps = Omit<TextProps, "variant">;
-declare const Heading1: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Heading2: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Heading3: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Heading4: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Heading5: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Body: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Small: React__default.ForwardRefExoticComponent<PresetProps & React__default.RefAttributes<HTMLElement>>;
-declare const Italic: ({ children }: {
-    children: ReactNode;
-}) => React__default.JSX.Element;
+type MenuViewportProps<T extends string> = {
+    items: MenuItem<T>[];
+    Components: MenuComponents;
+    onSelect?: (value: any) => void;
+};
+declare const MenuViewport: <T extends string>({ items, Components, onSelect, }: MenuViewportProps<T>) => React__default.JSX.Element;
+
+interface ContainerProps {
+    children: React.ReactNode;
+    renderLabel: (provided: {
+        id: string;
+        index: number;
+    }) => React.ReactNode;
+}
+declare const LabeledElementView: React.NamedExoticComponent<ContainerProps>;
+
+declare const labeledFieldStyles: (labelPosition?: LabelPosition) => string;
+declare const LabeledField: React__default.NamedExoticComponent<{
+    children: React__default.ReactNode;
+    label: React__default.ReactNode;
+    labelPosition?: LabelPosition;
+    /** Used for both the `id` of the field and the `htmlFor` of the label, unless `id` and `htmlFor` are explicitly provided */
+    fieldId?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    /** @default 100 */
+    minWidth?: number;
+}>;
+
+declare const List: <T, M extends string = string>(props: CollectionProps<T, M> & {
+    ref?: React__default.ForwardedRef<CollectionRef>;
+} & React__default.RefAttributes<CollectionRef>) => React__default.ReactElement | null;
+
+type MessageProps = {
+    role: "user" | "assistant" | "system" | "data";
+    children?: React__default.ReactNode;
+    user?: MultiplayerUser;
+    /** @default 27 */
+    avatarSize?: number;
+};
+declare const Message: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<MessageProps & React__default.RefAttributes<HTMLDivElement>>>;
+
+type PopoverVariant = "normal" | "large";
+interface Props$7 extends Pick<ComponentProps<(typeof PopoverPrimitive)["Content"]>, "onOpenAutoFocus" | "onCloseAutoFocus" | "onPointerDownOutside" | "onInteractOutside" | "onFocusOutside" | "side"> {
+    children: React__default.ReactNode;
+    trigger: React__default.ReactNode;
+    variant?: PopoverVariant;
+    closable?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    sideOffset?: number;
+    onClickClose?: () => void;
+    showArrow?: boolean;
+    className?: string;
+}
+declare function Popover({ children, trigger, variant, closable, open, side, sideOffset, showArrow, onOpenChange, onOpenAutoFocus, onCloseAutoFocus, onPointerDownOutside, onInteractOutside, onFocusOutside, onClickClose, className, }: Props$7): React__default.JSX.Element;
+
+type ProgressVariant = "normal" | "warning" | "primary" | "secondary";
+declare function Progress({ value, variant, className, }: {
+    value: number;
+    variant?: ProgressVariant;
+    className?: string;
+}): React.JSX.Element;
+
+interface Props$6 {
+    children?: React.ReactNode | ((scrollElementRef: HTMLDivElement) => React.ReactNode);
+}
+declare const ScrollArea: React.NamedExoticComponent<Props$6>;
+
+type SegmentedControlColorScheme = "primary" | "secondary";
+interface SegmentedControlProps<T extends string> {
+    id?: string;
+    value?: T;
+    onValueChange?: (value: T) => void;
+    /** @default primary */
+    colorScheme?: SegmentedControlColorScheme;
+    allowEmpty?: boolean;
+    separator?: boolean;
+    items: SegmentedControlItemProps<T>[];
+    className?: string;
+    style?: React__default.CSSProperties;
+}
+type SegmentedControlItemProps<T extends string> = {
+    title?: ReactNode;
+    className?: string;
+    style?: React__default.CSSProperties;
+    tooltip?: ReactNode;
+} & Pick<SelectableMenuItem<T>, "value" | "disabled" | "icon" | "role" | "title">;
+declare const SegmentedControl: <T extends string>(props: SegmentedControlProps<T>) => React__default.ReactElement | null;
+
+type Props$5<T extends string> = {
+    id?: string;
+    style?: React__default.CSSProperties;
+    className?: string;
+    items: MenuItem<T>[];
+    value: T;
+    onSelect?: (value: T) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    label?: React__default.ReactNode;
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+    contentStyle?: React__default.CSSProperties;
+} & Pick<SelectProps, "open" | "onOpenChange">;
+declare const SelectMenu: <T extends string = string>(props: Props$5<T>) => React__default.ReactElement | null;
+
+type ColorScheme = "primary" | "secondary";
+interface Props$4 {
+    id?: string;
+    style?: React__default.CSSProperties;
+    className?: string;
+    value: number;
+    onValueChange: (value: number) => void;
+    min: number;
+    max: number;
+    step?: number;
+    colorScheme?: ColorScheme;
+    label?: React__default.ReactNode;
+    onFocus?: FocusEventHandler;
+    onBlur?: FocusEventHandler;
+    readOnly?: boolean;
+}
+declare const Slider: React__default.NamedExoticComponent<Props$4>;
+
+interface Props$3 {
+    size?: number | string;
+    inline?: boolean;
+}
+declare namespace Spacer {
+    const Vertical: React.ForwardRefExoticComponent<Props$3 & React.RefAttributes<HTMLSpanElement>>;
+    const Horizontal: React.ForwardRefExoticComponent<Props$3 & React.RefAttributes<HTMLSpanElement>>;
+}
+
+type SwitchColorScheme = "primary" | "secondary";
+interface Props$2 {
+    id?: string;
+    value: boolean;
+    onChange: (value: boolean) => void;
+    /** @default normal */
+    colorScheme?: SwitchColorScheme;
+    disabled?: boolean;
+    onFocus?: React.FocusEventHandler;
+    onBlur?: React.FocusEventHandler;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const Switch: ({ id, value, onChange, colorScheme, disabled, onFocus, onBlur, style, className, }: Props$2) => React.JSX.Element;
 
 declare const useAutoResize: (value: string | undefined) => React__default.MutableRefObject<HTMLTextAreaElement | null>;
 declare const TextArea: React__default.MemoExoticComponent<React__default.ForwardRefExoticComponent<{
@@ -1243,18 +1497,20 @@ declare const ToastProvider: ({ children }: {
     children: React__default.ReactNode;
 }) => React__default.JSX.Element;
 
-interface Props$2 {
+interface Props$1 {
     children: React.ReactNode;
     content: React.ReactNode;
 }
-declare const Tooltip: React.NamedExoticComponent<Props$2>;
+declare const Tooltip: React.NamedExoticComponent<Props$1>;
 
 type TreeRowBaseProps = {
     icon?: Exclude<ReactNode, string> | IconName;
     expanded?: boolean;
+    chevronClassName?: string;
     onClickChevron?: ({ altKey }: {
         altKey: boolean;
     }) => void;
+    onDoubleClick?: () => void;
 };
 type TreeViewRowProps<MenuItemType extends string> = ListView.RowProps<MenuItemType> & TreeRowBaseProps;
 declare namespace TreeView {
@@ -1268,28 +1524,12 @@ declare namespace TreeView {
         keyExtractor: (item: T, index: number) => string;
         sortable?: boolean;
         virtualized?: _noya_app_noya_geometry.Size;
-    }) & {
-        id?: string;
-        className?: string;
-        style?: React__default.CSSProperties;
-        onPress?: () => void;
-        scrollable?: boolean;
-        expandable?: boolean;
-        onMoveItem?: (sourceIndex: number, destinationIndex: number, position: RelativeDropPosition) => void;
-        indentation?: number;
-        acceptsDrop?: DropValidator;
-        pressEventName?: "onClick" | "onPointerDown";
-        variant?: "normal" | "bare" | "padded";
-        sectionHeaderVariant?: "normal" | "label";
-        divider?: boolean;
-        gap?: number;
-        colorScheme?: "primary" | "secondary";
-    }) & React__default.RefAttributes<IVirtualizedList>) => React__default.ReactElement | null;
+    }) & ListViewRootProps) & React__default.RefAttributes<IVirtualizedList>) => React__default.ReactElement | null;
     const RowTitle: React__default.MemoExoticComponent<({ className, children, ...props }: {
         className?: string;
         children: React__default.ReactNode;
     } & React__default.HTMLAttributes<HTMLSpanElement>) => React__default.JSX.Element>;
-    const EditableRowTitle: React__default.MemoExoticComponent<({ value, onSubmitEditing, autoFocus, placeholder, }: EditableRowProps) => React__default.JSX.Element>;
+    const EditableRowTitle: React__default.MemoExoticComponent<({ value, onSubmitEditing, autoFocus, placeholder, className, }: EditableRowProps) => React__default.JSX.Element>;
     const Row: <MenuItemType extends string>(props: ListView.RowProps<MenuItemType> & TreeRowBaseProps & React__default.RefAttributes<HTMLLIElement>) => React__default.ReactElement | null;
     type ClickInfo = ListView.ClickInfo;
     type RowProps<MenuItemType extends string> = TreeViewRowProps<MenuItemType>;
@@ -1322,10 +1562,11 @@ type PanelLayoutState = {
 };
 declare function usePreservePanelSize(panelGroupRef: React__default.RefObject<ImperativePanelGroupHandle | null>, setPanelLayoutState?: (state: PanelLayoutState) => void): void;
 
-interface Props$1 {
+interface WorkspaceLayoutProps {
     id?: string;
     className?: string;
     style?: React__default.CSSProperties;
+    theme?: "light" | "dark";
     autoSavePrefix?: string;
     left?: React__default.ReactNode;
     leftOptions?: SideOptions;
@@ -1352,8 +1593,9 @@ type SideOptions = {
      */
     initialSize?: number | string;
     minSize?: number | string;
+    maxSize?: number | string;
 };
-declare const WorkspaceLayout: React__default.ForwardRefExoticComponent<Props$1 & React__default.RefAttributes<IWorkspaceLayout>>;
+declare const WorkspaceLayout: React__default.ForwardRefExoticComponent<WorkspaceLayoutProps & React__default.RefAttributes<IWorkspaceLayout>>;
 
 type DesignSystemConfigurationContextValue = {
     platform: PlatformName;
@@ -1462,6 +1704,34 @@ interface HoverResult {
  */
 declare function useHover(props?: HoverProps): HoverResult;
 
+declare const IndentContext: React__default.Context<{
+    indentLevel: number;
+}>;
+declare const useIndent: () => number;
+
+declare const LabelContext: React__default.Context<{
+    fieldId?: string;
+    label?: React__default.ReactNode;
+}>;
+type UseLabelParams = {
+    label?: ReactNode;
+    fieldId?: string;
+};
+declare const useLabel: ({ label, fieldId }: UseLabelParams) => {
+    label: React__default.ReactNode;
+    fieldId: string | undefined;
+};
+declare const LabelPositionContext: React__default.Context<LabelPositionContextValue>;
+declare const useLabelPosition: () => LabelPosition;
+type LabelPositionContextValue = {
+    position: LabelPosition;
+};
+type LabelWidthContextValue = {
+    width: number;
+};
+declare const LabelWidthContext: React__default.Context<LabelWidthContextValue>;
+declare const useLabelWidth: () => number;
+
 declare function usePlatform(): _noya_app_noya_keymap.PlatformName;
 /**
  * Either ctrl or meta, depending on the platform
@@ -1492,7 +1762,7 @@ declare const mediaQuery: {
 declare function cx(...args: Array<string | number | boolean | null | undefined>): string;
 
 type Optional<T> = T | false | null | undefined;
-type MenuConfig<T extends string> = Optional<Optional<RegularMenuItem<T>>[]>[];
+type MenuConfig<T extends string> = Optional<Optional<MenuItem<T>>[]>[];
 declare function createSectionedMenu<T extends string>(...sections: MenuConfig<T>): MenuItem<T>[];
 
 declare function getGradientBackground(value: Sketch.GradientStop[], type: Sketch.GradientType, direction?: number): string;
@@ -1504,6 +1774,52 @@ declare const colorForStringValues: Record<string, string>;
  */
 declare function colorFromString(str: string): string;
 
+type ComboboxStateSnapshot<T extends string> = {
+    filter: string;
+    selectedIndex: number;
+    filteredItems: ScoredMenuItem<T>[];
+    lastSubmittedValue: {
+        filter: string;
+        itemName: string;
+    };
+};
+declare class ComboboxState<T extends string> {
+    private filter;
+    private selectedIndex;
+    private items;
+    private lastSubmittedValue;
+    private subscribers;
+    private version;
+    private _cachedSnapshot;
+    constructor(items: MenuItem<T>[], initialTitle: string, allowArbitraryValues: boolean);
+    subscribe: (listener: () => void) => (() => void);
+    private notifyChange;
+    private getFilteredItems;
+    getSnapshot: () => ComboboxStateSnapshot<T>;
+    setItems(items: MenuItem<T>[]): void;
+    setFilter(filter: string): void;
+    moveSelection(direction: "up" | "down"): void;
+    selectCurrentItem(item?: ScoredMenuItem<T>): SelectableMenuItem<T> | undefined;
+    restoreLastSubmittedValue(): void;
+    reset(newFilter?: string): void;
+    getSelectedItem(): ScoredMenuItem<T> | undefined;
+    getTypeaheadValue(): string | undefined;
+    setSelectedIndex(index: number): void;
+    submitArbitraryFilter(filter: string): void;
+}
+declare function getNextIndex<T>(items: T[], currentIndex: number, direction: "next" | "previous", isDisabled: (item: T) => boolean): number;
+declare function useComboboxState<T extends string>(state: ComboboxState<T>): ComboboxStateSnapshot<T>;
+
+/**
+ * Updates the selection state based on user interaction.
+ * Handles single selection, multi-selection with meta/ctrl, and range selection with shift.
+ */
+declare function updateSelection(allIds: string[], selectedIds: string[], clickedId: string, event?: {
+    shiftKey?: boolean;
+    metaKey?: boolean;
+    ctrlKey?: boolean;
+}): string[];
+
 declare function sketchColorToRgba(value: Sketch.Color): RgbaColor;
 declare function sketchColorToRgbaString(value: Sketch.Color): string;
 declare function rgbaToSketchColor(value: RgbaColor): Sketch.Color;
@@ -1593,4 +1909,4 @@ declare function ToolbarMenu<T extends string>({ items, onSelectMenuItem, }: {
     onSelectMenuItem?: (value: T) => void;
 }): React__default.JSX.Element;
 
-export { ActivityIndicator, AnimatePresence, type AnimatePresenceProps, Avatar, type AvatarProps, AvatarStack, type BaseComboboxProps, BaseToolbar, type BaseToolbarProps, Body, Button, type ButtonRootProps, CONTENT_AREA_ID, Checkbox$1 as Checkbox, Chip, type ChipProps, Combobox, type ComboboxItem, ComboboxMenu, type ComboboxOption, type ComboboxProps, type ComboboxRef, type ComboboxSectionHeader, ComboboxState, type ComboboxStateSnapshot, ContextMenu, type DesignSystemConfigurationContextValue, DesignSystemConfigurationProvider, Dialog, type DialogContextValue, DialogProvider, DimensionInput, type DimensionValue, Divider, DividerVertical, DraggableMenuButton, type DropValidator, DropdownMenu, EDITOR_PANEL_GROUP_ID, type EditableRowProps, type ExtractMenuItemType, FillInputField, FillPreviewBackground, FloatingWindow, FloatingWindowProvider, FullscreenDialog, type GlobalInputBlurContextValue, GlobalInputBlurProvider, GradientPicker, GridView, type GridViewSize, Heading1, Heading2, Heading3, Heading4, Heading5, type HoverEvent, type HoverEvents, type HoverProps, type IDialog, type IScoredItem, type IToken, type IVirtualizedList, type IWorkspaceLayout, IconButton, type IconName, type ImageDataContextValue, ImageDataProvider, InputField, type InputFieldInputProps, type InputFieldSize, InspectorContainer, InspectorPrimitives, type InternalComboboxItem, Italic, KeyboardShortcut, LEFT_SIDEBAR_ID, Label, LabeledElementView, type ListRowMarginType, type ListRowPosition, ListView, type MatchRange, type MenuConfig, type MenuItem, type MenuItemProps, type MenuProps, Message, type MessageProps, type OptionModeOnlyProps, type OptionModeProps, type Optional, type PanelLayoutState, PatternPreviewBackground, Popover, Progress, RIGHT_SIDEBAR_ID, type RegularMenuItem, type RelativeDropPosition, SEPARATOR_ITEM, SUPPORTED_CANVAS_UPLOAD_TYPES, SUPPORTED_IMAGE_UPLOAD_TYPES, ScrollArea, SegmentedControl, type SegmentedControlItemProps, type SegmentedControlProps, SelectMenu, type SetNumberMode, type SideOptions, type SketchPattern, Slider, Small, Sortable, Spacer, type StringModeOnlyProps, type StringModeProps, type SupportedCanvasUploadType, type SupportedImageUploadType, Switch, Text$1 as Text, TextArea, TextAreaRow, type TextProps, type Theme, type ThemeColor, Toast, ToastProvider, Toolbar, ToolbarMenu, type ToolbarProps, Tooltip, TreeView, type UseThemeReturnType, UserPointer, type UserPointerProps, WorkspaceLayout, colorForStringValues, colorFromString, createSectionedMenu, cssVars, cx, fuzzyFilter, fuzzyScore, fuzzyTokenize, getGradientBackground, getKeyboardShortcutsForMenuItems, getNewValue, labelTextStyles, mediaQuery, normalizeListDestinationIndex, renderIcon, rgbaToSketchColor, size, sketchColorToHex, sketchColorToRgba, sketchColorToRgbaString, textStyles, useAutoResize, useComboboxState, useCurrentFloatingWindowInternal, useDesignSystemConfiguration, useDialogContainsElement, useFloatingWindowManager, useGlobalInputBlur, useGlobalInputBlurListener, useGlobalInputBlurTrigger, useHover, useImageData, useOpenConfirmationDialog, useOpenInputDialog, usePlatform, usePlatformModKey, usePreservePanelSize, useTheme, withSeparatorElements };
+export { ActivityIndicator, AnimatePresence, type AnimatePresenceProps, Avatar, type AvatarProps, AvatarStack, type BaseComboboxProps, BaseToolbar, type BaseToolbarProps, Body, BreadcrumbText, Button, type ButtonRootProps, CHECKBOX_RIGHT_INSET, CHECKBOX_WIDTH, CONTENT_AREA_ID, Checkbox$1 as Checkbox, Chip, type ChipProps, Collection, type CollectionProps, type CollectionRef, type CollectionViewType, Combobox, ComboboxMenu, type ComboboxProps, type ComboboxRef, ComboboxState, type ComboboxStateSnapshot, CommandPalette, ContextMenu, type DesignSystemConfigurationContextValue, DesignSystemConfigurationProvider, Dialog, type DialogContextValue, DialogProvider, DimensionInput, type DimensionValue, Divider, DividerVertical, DraggableMenuButton, type DropValidator, DropdownMenu, type DropdownRootProps, EDITOR_PANEL_GROUP_ID, type EditableRowProps, EditableText, type EditableTextRef, type ExtractMenuItemType, Fade, type FadeDirection, type FadeProps, FillInputField, FillPreviewBackground, FloatingWindow, FloatingWindowProvider, FullscreenDialog, type GlobalInputBlurContextValue, GlobalInputBlurProvider, GradientPicker, Grid, GridView, type GridViewSize, Heading1, Heading2, Heading3, Heading4, Heading5, type HoverEvent, type HoverEvents, type HoverProps, type IDialog, type IScoredItem, type ISearchCompletionMenu, type IToken, type IVirtualizedList, type IWorkspaceLayout, IconButton, type IconName, type ImageDataContextValue, ImageDataProvider, IndentContext, InputField, type InputFieldInputProps, type InputFieldProps, type InputFieldSize, InsetLabel, type InsetLabelProps, InspectorContainer, InspectorPrimitives, Italic, KeyboardShortcut, LEFT_SIDEBAR_ID, Label, LabelContext, type LabelPosition, LabelPositionContext, type LabelPositionContextValue, type LabelProps, LabelWidthContext, type LabelWidthContextValue, LabeledElementView, LabeledField, List, type ListRowMarginType, type ListRowPosition, ListView, type ListViewRootProps, type MatchRange, type MenuComponents, type MenuConfig, type MenuItem, type MenuItemProps, type MenuItemRole, type MenuProps, MenuViewport, Message, type MessageProps, type NonSelectableMenuItem, type OptionModeOnlyProps, type OptionModeProps, type Optional, type PanelLayoutState, PatternPreviewBackground, Popover, Progress, RIGHT_SIDEBAR_ID, type RelativeDropPosition, SUPPORTED_CANVAS_UPLOAD_TYPES, SUPPORTED_IMAGE_UPLOAD_TYPES, type ScoredMenuItem, ScrollArea, SearchCompletionMenu, SectionHeader$1 as SectionHeader, type SectionHeaderMenuItem, SegmentedControl, type SegmentedControlItemProps, type SegmentedControlProps, SelectMenu, type SelectableMenuItem, type SeparatorItem, type SetNumberMode, type SideOptions, type SketchPattern, Slider, Small, Sortable, Spacer, type StringModeOnlyProps, type StringModeProps, type SupportedCanvasUploadType, type SupportedImageUploadType, Switch, Text$1 as Text, TextArea, TextAreaRow, type TextProps, type Theme, type ThemeColor, Toast, ToastProvider, Toolbar, ToolbarMenu, type ToolbarProps, Tooltip, TreeView, type UseThemeReturnType, UserPointer, type UserPointerProps, WorkspaceLayout, type WorkspaceLayoutProps, colorForStringValues, colorFromString, createSectionedMenu, cssVars, cx, fuzzyFilter, fuzzyScore, fuzzyTokenize, getFieldSpacing, getGradientBackground, getGridSize, getKeyboardShortcutsForMenuItems, getNewValue, getNextIndex, insetLabelStyles, insetLabelTextStyles, isMenuItemSectionHeader, isNonSelectableMenuItem, isSelectableMenuItem, isSelectableMenuItemWithScore, labeledFieldStyles, mediaQuery, normalizeListDestinationIndex, renderIcon, rgbaToSketchColor, size, sketchColorToHex, sketchColorToRgba, sketchColorToRgbaString, styles, textStyles, updateSelection, useAutoResize, useComboboxState, useCurrentFloatingWindowInternal, useDesignSystemConfiguration, useDialogContainsElement, useFloatingWindowManager, useGlobalInputBlur, useGlobalInputBlurListener, useGlobalInputBlurTrigger, useHover, useImageData, useIndent, useInputFieldContext, useLabel, useLabelPosition, useLabelWidth, useOpenConfirmationDialog, useOpenInputDialog, usePlatform, usePlatformModKey, usePreservePanelSize, useTheme, withSeparatorElements };