@noya-app/noya-designsystem 0.1.35 → 0.1.36

package/dist/index.d.mts

@@ -0,0 +1,1053 @@
+import * as React$1 from 'react';
+import React__default, { CSSProperties, ReactNode, ComponentProps, SyntheticEvent, AriaRole, KeyboardEventHandler, MouseEventHandler, PointerEventHandler, FocusEventHandler, InputHTMLAttributes, Ref, ReactHTML } from 'react';
+import * as Icons from '@noya-app/noya-icons';
+export { Icons };
+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 { Property } from 'csstype';
+import * as _noya_app_noya_geometry from '@noya-app/noya-geometry';
+import { Size } from '@noya-app/noya-geometry';
+import { IItemScore } from 'vscode-fuzzy-scorer';
+import { useSortable } from '@dnd-kit/sortable';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { SelectProps } from '@radix-ui/react-select';
+import { Config } from 'tailwindcss';
+import { ImperativePanelGroupHandle } from 'react-resizable-panels';
+import { RgbaColor } from '@noya-app/noya-colorpicker';
+
+interface Props$f {
+    size?: number;
+    opacity?: number;
+    color?: string;
+    trackColor?: string;
+}
+declare const ActivityIndicator: (props: Props$f) => React__default.ReactElement | null;
+
+declare const Avatar: (props: {
+    image?: string;
+    name?: string;
+    fallback?: string;
+    size?: number;
+    overflow?: number;
+    style?: React__default.CSSProperties;
+    className?: string;
+} & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+declare function AvatarStack({ size, children, }: {
+    size?: number;
+    children: React__default.ReactNode;
+}): React__default.JSX.Element;
+
+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: (props: ButtonRootProps & React__default.RefAttributes<HTMLButtonElement>) => React__default.ReactElement | null;
+
+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: (props: ChipProps & React__default.RefAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+
+type IconName = keyof typeof Icons;
+
+declare function renderIcon(iconName: Exclude<ReactNode, string> | IconName): ReactNode;
+
+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 MenuItem<T extends string> = typeof SEPARATOR_ITEM | RegularMenuItem<T>;
+type ExtractMenuItemType<T> = T extends RegularMenuItem<infer U> ? U : never;
+declare const KeyboardShortcut: (props: {
+    shortcut: string;
+}) => 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>[];
+}
+interface MenuProps<T extends string> {
+    children: ReactNode;
+    items: MenuItem<T>[];
+    onSelect: (value: T) => void;
+    isNested?: boolean;
+    shouldBindKeyboardShortcuts?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const ContextMenu: <T extends string>(props: MenuProps<T>) => React__default.ReactElement | null;
+
+declare const StyledContent: (props: Omit<DialogPrimitive.DialogContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+interface IDialog {
+    containsElement: (element: HTMLElement) => boolean;
+}
+interface Props$e {
+    title?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    style?: ComponentProps<typeof StyledContent>["style"];
+    open: ComponentProps<typeof DialogPrimitive.Root>["open"];
+    onOpenChange?: ComponentProps<typeof DialogPrimitive.Root>["onOpenChange"];
+    onOpenAutoFocus?: ComponentProps<typeof DialogPrimitive.Content>["onOpenAutoFocus"];
+    closeOnInteractOutside?: boolean;
+}
+declare const Dialog: (props: Props$e & React__default.RefAttributes<IDialog>) => React__default.ReactElement | null;
+declare const FullscreenDialog: (props: Props$e & React__default.RefAttributes<IDialog>) => React__default.ReactElement | null;
+
+type DividerVariant = "normal" | "subtle" | "strong";
+interface DividerProps {
+    variant?: DividerVariant;
+    overflow?: number | string;
+    className?: string;
+    style?: React__default.CSSProperties;
+}
+declare const Divider: (props: DividerProps) => React__default.ReactElement | null;
+declare const DividerVertical: (props: DividerProps) => React__default.ReactElement | null;
+
+/**
+ * A button that opens a menu when clicked, but also allows dragging the
+ */
+declare const DraggableMenuButton: <T extends string>(props: {
+    items?: MenuItem<T>[];
+    onSelect?: (value: T) => void;
+    isVisible?: boolean;
+}) => React__default.ReactElement | null;
+
+declare const DropdownMenu: <T extends string>(props: MenuProps<T> & {
+    open?: boolean;
+    onCloseAutoFocus?: React__default.EventHandler<SyntheticEvent<unknown>>;
+    emptyState?: React__default.ReactNode;
+} & Pick<RadixDropdownMenu.DropdownMenuContentProps & React__default.RefAttributes<HTMLDivElement>, "align" | "side" | "sideOffset" | "alignOffset" | "collisionPadding"> & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+
+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];
+type SupportedCanvasUploadType = (typeof SUPPORTED_CANVAS_UPLOAD_TYPES)[number];
+type SketchPattern = {
+    _class: 'pattern';
+    image?: Sketch.FileRef | Sketch.DataRef;
+    patternFillType: Sketch.PatternFillType;
+    patternTileScale: number;
+};
+
+interface Props$d {
+    id?: string;
+    value?: Sketch.Color | Sketch.Gradient | SketchPattern;
+}
+declare const FillInputField: (props: Props$d & React__default.RefAttributes<HTMLButtonElement>) => React__default.ReactElement | null;
+
+declare const PatternPreviewBackground: (props: {
+    fillType: Sketch.PatternFillType;
+    tileScale: number;
+    imageRef: string;
+}) => React__default.ReactElement | null;
+interface Props$c {
+    value?: Sketch.Color | Sketch.Gradient | SketchPattern;
+}
+declare const FillPreviewBackground: (props: Props$c) => React__default.ReactElement | null;
+
+interface FloatingWindowProps {
+    title?: string;
+    onClose?: () => void;
+    children: React__default.ReactNode;
+    initialWidth?: number;
+    initialHeight?: number;
+    initialX?: number;
+    initialY?: number;
+    minWidth?: number;
+    minHeight?: number;
+    toolbarContent?: React__default.ReactNode;
+    renderToolbar?: (props: {
+        title?: string;
+        toolbarContent?: React__default.ReactNode;
+        onClose?: () => void;
+    }) => React__default.ReactNode;
+}
+declare const FloatingWindow: React__default.FC<FloatingWindowProps>;
+
+interface Props$b {
+    value: Sketch.GradientStop[];
+    selectedStop: number;
+    onChangeColor: (color: Sketch.Color) => void;
+    onChangePosition: (position: number) => void;
+    onAdd: (color: Sketch.Color, position: number) => void;
+    onDelete: () => void;
+    onSelectStop: (index: number) => void;
+}
+declare const GradientPicker: (props: Props$b) => React__default.ReactElement | null;
+
+type GridViewSize = "xxs" | "xs" | "small" | "medium" | "large" | "xl";
+interface ItemProps$2<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 namespace GridView {
+    const Root: (props: GridViewRootProps) => React__default.ReactElement | null;
+    const Item: <MenuItemType extends string>(props: ItemProps$2<MenuItemType> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+    const Section: (props: {
+        children?: ReactNode;
+        className?: string;
+    }) => React__default.ReactElement | null;
+    const SectionHeader: (props: {
+        title: string;
+    }) => React__default.ReactElement | null;
+}
+
+declare const IconButton: (props: Omit<ButtonRootProps, "size" | "flex" | "children" | "variant"> & {
+    iconName: IconName;
+    className?: string;
+    style?: CSSProperties;
+    selected?: boolean;
+    color?: string;
+    size?: number;
+} & React__default.RefAttributes<HTMLButtonElement>) => React__default.ReactElement | null;
+
+type Props$a = {
+    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$a & {
+    readOnly: true;
+};
+type ControlledProps = Props$a & {
+    onChange: (value: string) => void;
+};
+type SubmittableProps = Props$a & {
+    onSubmit: (value: string) => void;
+    allowSubmittingWithSameValue?: boolean;
+    submitAutomaticallyAfterDelay?: number;
+};
+type TextInputProps = ReadOnlyProps | ControlledProps | SubmittableProps;
+
+type LabelPosition = "start" | "end";
+type InputFieldSize = "small" | "medium" | "large";
+interface InputFieldLabelProps {
+    children?: ReactNode;
+    pointerEvents?: Property.PointerEvents;
+    style?: React__default.CSSProperties;
+    className?: string;
+}
+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"> & {
+    value: number | undefined;
+    onNudge?: (value: number) => void;
+    variant?: "bare";
+} & ({
+    onChange: (value: number) => void;
+} | {
+    onSubmit: (value: number) => void;
+});
+interface InputFieldRootProps {
+    id?: string;
+    flex?: string;
+    children?: ReactNode;
+    width?: number;
+    /** @default end */
+    labelPosition?: LabelPosition;
+    labelSize?: number;
+    hasDropdown?: boolean;
+    /** @default medium */
+    size?: InputFieldSize;
+    renderPopoverContent?: (options: {
+        width: number;
+    }) => ReactNode;
+    onFocusChange?: (isFocused: boolean) => void;
+    style?: React__default.CSSProperties;
+    className?: string;
+}
+declare namespace InputField {
+    const Root: (props: InputFieldRootProps) => React__default.ReactElement | null;
+    const Input: (props: InputFieldInputProps & React__default.RefAttributes<HTMLInputElement>) => React__default.ReactElement | null;
+    const Typeahead: (props: {
+        prefix: string;
+        value: string;
+    }) => React__default.ReactElement | null;
+    const NumberInput: (props: InputFieldNumberInputProps) => React__default.ReactElement | null;
+    const DropdownMenu: <T extends string>(props: InputFieldDropdownProps<T>) => React__default.ReactElement | null;
+    const Button: (props: React__default.ButtonHTMLAttributes<HTMLButtonElement> & React__default.RefAttributes<HTMLButtonElement>) => React__default.ReactElement | null;
+    const Label: (props: InputFieldLabelProps & React__default.RefAttributes<HTMLLabelElement>) => React__default.ReactElement | null;
+    const PrimitiveElement: ({ readOnly, disabled, className, ...props }: {
+        readOnly?: boolean;
+        disabled?: boolean;
+    } & React__default.DetailedHTMLProps<React__default.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>) => React__default.JSX.Element;
+}
+
+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 function fuzzyTokenize({ item, itemScore, }: {
+    item: string;
+    itemScore: IItemScore;
+}): IToken[];
+
+type CompletionItem = {
+    type?: undefined;
+    id: string;
+    name: string;
+    icon?: ReactNode;
+    alwaysInclude?: boolean;
+};
+type CompletionSectionHeader = {
+    type: 'sectionHeader';
+    id: string;
+    name: string;
+    maxVisibleItems?: number;
+};
+type CompletionListItem = (CompletionItem & IScoredItem) | CompletionSectionHeader;
+
+type RelativeDropPosition = "above" | "below" | "inside";
+type DropValidator = (sourceIndex: number, destinationIndex: number, position: RelativeDropPosition) => boolean;
+declare const normalizeListDestinationIndex: (index: number, position: "above" | "below") => number;
+type UseSortableReturnType = ReturnType<typeof useSortable>;
+interface ItemProps$1<T> {
+    id: string;
+    disabled?: boolean;
+    children: (props: {
+        ref: Ref<T>;
+        relativeDropPosition?: RelativeDropPosition;
+        [key: string]: any;
+    } & UseSortableReturnType["attributes"]) => JSX.Element;
+}
+interface RootProps {
+    keys: string[];
+    children: ReactNode;
+    renderOverlay?: (index: number) => ReactNode;
+    onMoveItem?: (sourceIndex: number, destinationIndex: number, position: RelativeDropPosition) => void;
+    acceptsDrop?: DropValidator;
+    axis?: "x" | "y";
+}
+declare namespace Sortable {
+    const Item: <T extends HTMLElement>(props: ItemProps$1<T>) => React__default.ReactElement | null;
+    const Root: (props: RootProps) => React__default.ReactElement | null;
+}
+
+type ListRowMarginType = "none" | "top" | "bottom" | "vertical";
+type ListRowPosition = "only" | "first" | "middle" | "last";
+type ListColorScheme = "primary" | "secondary";
+type PressEventName = "onClick" | "onPointerDown";
+type ListRowContextValue = {
+    marginType: ListRowMarginType;
+    selectedPosition: ListRowPosition;
+    sortable: boolean;
+    expandable: boolean;
+    divider: boolean;
+    gap: number;
+    variant: ListViewVariant;
+    sectionHeaderVariant: ListViewSectionHeaderVariant;
+    pressEventName: PressEventName;
+    isSectionHeader: boolean;
+    colorScheme: ListColorScheme;
+};
+interface EditableRowProps {
+    value: string;
+    onSubmitEditing: (value: string) => void;
+    autoFocus: boolean;
+    placeholder?: string;
+}
+interface ListViewClickInfo {
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    ctrlKey: boolean;
+}
+interface ListViewRowProps<MenuItemType extends string = string> {
+    id?: string;
+    tabIndex?: number;
+    selected?: boolean;
+    /** @default 0 */
+    depth?: number;
+    disabled?: boolean;
+    hovered?: boolean;
+    sortable?: boolean;
+    gap?: number;
+    backgroundColor?: CSSProperties["backgroundColor"];
+    onPress?: (info: ListViewClickInfo) => void;
+    onDoubleClick?: () => void;
+    onHoverChange?: (isHovering: boolean) => void;
+    children?: ReactNode;
+    isSectionHeader?: boolean;
+    menuItems?: MenuItem<MenuItemType>[];
+    onSelectMenuItem?: (value: MenuItemType) => void;
+    onContextMenu?: () => void;
+    onMenuOpenChange?: (isOpen: boolean) => void;
+    onKeyDown?: (event: React__default.KeyboardEvent) => void;
+    style?: CSSProperties;
+    className?: string;
+    dragIndicatorStyle?: CSSProperties | ((props: {
+        depth: number;
+        indentation: number;
+        position: RelativeDropPosition;
+    }) => CSSProperties);
+}
+interface IVirtualizedList {
+    scrollToIndex(index: number): void;
+}
+type ListViewItemInfo = {
+    isDragging: boolean;
+};
+type ChildrenProps = {
+    children: ReactNode;
+};
+type RenderProps<T> = {
+    data: T[];
+    renderItem: (item: T, index: number, info: ListViewItemInfo) => ReactNode;
+    keyExtractor: (item: T, index: number) => string;
+    /**
+     * Each item must have an `id` in order to be sortable.
+     *
+     * Additionally, the key extracted with `keyExtractor` must match the ListItem.Row `id`.
+     */
+    sortable?: boolean;
+    virtualized?: Size;
+};
+type ListViewVariant = "normal" | "padded" | "bare";
+type ListViewSectionHeaderVariant = "normal" | "label";
+type ListViewRootProps = {
+    id?: string;
+    className?: string;
+    style?: CSSProperties;
+    onPress?: () => void;
+    scrollable?: boolean;
+    expandable?: boolean;
+    onMoveItem?: (sourceIndex: number, destinationIndex: number, position: RelativeDropPosition) => void;
+    indentation?: number;
+    acceptsDrop?: DropValidator;
+    pressEventName?: PressEventName;
+    variant?: ListViewVariant;
+    sectionHeaderVariant?: ListViewSectionHeaderVariant;
+    divider?: boolean;
+    gap?: number;
+    colorScheme?: ListColorScheme;
+};
+declare namespace ListView {
+    const RowTitle: (props: {
+        className?: string;
+        children: React__default.ReactNode;
+    } & React__default.HTMLAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+    const EditableRowTitle: (props: EditableRowProps) => React__default.ReactElement | null;
+    const Row: <MenuItemType extends string>(props: ListViewRowProps<MenuItemType> & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+    const Root: <T = any>(props: ((ChildrenProps | RenderProps<T>) & ListViewRootProps) & React__default.RefAttributes<IVirtualizedList>) => React__default.ReactElement | null;
+    const RowContext: React__default.Context<ListRowContextValue>;
+    type ClickInfo = ListViewClickInfo;
+    type ItemInfo = ListViewItemInfo;
+    type RowProps<MenuItemType extends string = string> = ListViewRowProps<MenuItemType>;
+    type VirtualizedList = IVirtualizedList;
+    const DragIndicator: (props: React__default.HTMLAttributes<HTMLDivElement> & {
+        $relativeDropPosition: RelativeDropPosition;
+        $gap: number;
+        $offsetLeft: number;
+        $colorScheme: ListColorScheme;
+    } & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+    const rowHeight = 31;
+    const sectionHeaderLabelHeight = 27;
+    const calculateHeight: (items: number, headerCount: number, headerVariant: ListViewSectionHeaderVariant) => number;
+    const normalizeDestinationIndex: (index: number, position: "above" | "below") => number;
+}
+
+interface CompletionMenuProps {
+    items: CompletionListItem[];
+    selectedIndex: number;
+    onSelectItem: (item: CompletionListItem) => void;
+    onHoverIndex: (index: number) => void;
+    listSize: Size;
+}
+declare const CompletionMenu: (props: CompletionMenuProps & React__default.RefAttributes<IVirtualizedList>) => React__default.ReactElement | null;
+type InputFieldWithCompletionsProps = {
+    loading?: boolean;
+    initialValue?: string;
+    placeholder?: string;
+    items: (CompletionItem | CompletionSectionHeader)[];
+    onChange?: (value: string) => void;
+    onHoverItem?: (item: CompletionItem | undefined) => void;
+    onSelectItem?: (item: CompletionItem) => void;
+    onFocus?: (event: React__default.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (didSubmit: boolean, value: string) => void;
+    onDeleteWhenEmpty?: () => void;
+    size?: InputFieldSize;
+    style?: React__default.CSSProperties;
+    className?: string;
+    children?: React__default.ReactNode;
+    hideChildrenWhenFocused?: boolean;
+    hideMenuWhenEmptyValue?: boolean;
+};
+interface InputFieldWithCompletionsRef {
+    focus(): void;
+    setValue(value: string): void;
+    selectAllInputText(): void;
+}
+declare const InputFieldWithCompletions: (props: InputFieldWithCompletionsProps & React__default.RefAttributes<InputFieldWithCompletionsRef>) => React__default.ReactElement | null;
+
+declare const InspectorContainer: (props: {
+    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>) => React__default.ReactElement | null;
+
+interface LabelRootProps {
+    label: ReactNode;
+    children: ReactNode;
+}
+declare namespace Label {
+    const Root: (props: LabelRootProps) => React__default.ReactElement | null;
+}
+
+interface ContainerProps {
+    children: ReactNode;
+    renderLabel: (provided: {
+        id: string;
+        index: number;
+    }) => ReactNode;
+}
+declare const LabeledElementView: (props: ContainerProps) => React__default.ReactElement | null;
+
+type PopoverVariant = "normal" | "large";
+interface Props$9 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$9): React__default.JSX.Element;
+
+type ProgressVariant = "normal" | "warning" | "primary" | "secondary";
+declare function Progress({ value, variant, className, }: {
+    value: number;
+    variant?: ProgressVariant;
+    className?: string;
+}): React__default.JSX.Element;
+
+type RadioGroupColorScheme = "primary" | "secondary";
+interface ItemProps {
+    value: string;
+    tooltip?: ReactNode;
+    children: ReactNode;
+    disabled?: boolean;
+}
+interface Props$8 {
+    id?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    /** @default primary */
+    colorScheme?: RadioGroupColorScheme;
+    allowEmpty?: boolean;
+    children: ReactNode;
+}
+declare namespace RadioGroup {
+    const Root: (props: Props$8) => React__default.ReactElement | null;
+    const Item: (props: ItemProps & React__default.RefAttributes<HTMLButtonElement>) => React__default.ReactElement | null;
+}
+
+interface Props$7 {
+    children?: ReactNode | ((scrollElementRef: HTMLDivElement) => ReactNode);
+}
+declare const ScrollArea: (props: Props$7) => React__default.ReactElement | null;
+
+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;
+} & Pick<SelectProps, "open">;
+declare const SelectMenu: <T extends string = string>(props: Props$6<T>) => React__default.ReactElement | null;
+
+interface Props$5 {
+    id?: string;
+    value: number;
+    onValueChange: (value: number) => void;
+    min: number;
+    max: number;
+}
+declare const Slider: ({ id, value, onValueChange, min, max, }: Props$5) => React__default.JSX.Element;
+
+interface Props$4 {
+    size?: number | string;
+    inline?: boolean;
+}
+declare namespace Spacer {
+    const Vertical: (props: Props$4 & React__default.RefAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+    const Horizontal: (props: Props$4 & React__default.RefAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+}
+
+type SwitchColorScheme = "normal" | "primary" | "secondary";
+interface Props$3 {
+    value: boolean;
+    onChange: (value: boolean) => void;
+    /** @default normal */
+    colorScheme?: SwitchColorScheme;
+    disabled?: boolean;
+}
+declare const Switch: ({ value, onChange, colorScheme, disabled, }: Props$3) => React__default.JSX.Element;
+
+declare const config: Config;
+
+type Theme = typeof config.theme.extend;
+
+/**
+ * Utility for merging classes conditionally. Right side will override left side if there are any conflicts.
+ * Usage: cn('bg-red-500 text-white', 'bg-blue-500') // Returns: 'text-white bg-blue-500'
+ * @danger do not use this function to concatenate class names. Use it to merge classes conditionally.
+*/
+declare const cn: (...classes: (string | boolean | undefined | null)[]) => string;
+type ThemeExtend = NonNullable<Theme['extend']>;
+type ThemeColor = keyof ThemeExtend['colors'];
+
+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?: ThemeColor;
+    children: ReactNode;
+    onClick?: () => void;
+    onDoubleClick?: () => void;
+    onKeyDown?: (event: React__default.KeyboardEvent<HTMLSpanElement>) => void;
+    tabIndex?: number;
+};
+declare const Text$1: (props: TextProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+type PresetProps = Omit<TextProps, "variant">;
+declare const Heading1: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Heading2: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Heading3: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Heading4: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Heading5: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Body: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Small: (props: PresetProps & React__default.RefAttributes<HTMLElement>) => React__default.ReactElement | null;
+declare const Italic: ({ children }: {
+    children: ReactNode;
+}) => React__default.JSX.Element;
+
+declare const useAutoResize: (value: string) => React__default.MutableRefObject<HTMLTextAreaElement | null>;
+declare const AutoResizingTextArea: (props: {
+    onChangeText: (value: string) => void;
+    value?: string;
+} & React__default.TextareaHTMLAttributes<HTMLTextAreaElement> & React__default.RefAttributes<HTMLTextAreaElement>) => React__default.ReactElement | null;
+
+declare const Toast: ({ title, content, children, ...props }: {
+    title?: string;
+    content: ReactNode;
+    children?: React__default.ReactNode;
+}) => React__default.JSX.Element;
+declare const ToastProvider: ({ children }: {
+    children: React__default.ReactNode;
+}) => React__default.JSX.Element;
+
+interface Props$2 {
+    children: ReactNode;
+    content: ReactNode;
+}
+declare const Tooltip: (props: Props$2) => React__default.ReactElement | null;
+
+type TreeRowBaseProps = {
+    icon?: Exclude<ReactNode, string> | IconName;
+    expanded?: boolean;
+    onClickChevron?: ({ altKey }: {
+        altKey: boolean;
+    }) => void;
+};
+type TreeViewRowProps<MenuItemType extends string> = ListView.RowProps<MenuItemType> & TreeRowBaseProps;
+declare namespace TreeView {
+    const Root: <T = any>(props: (({
+        children: ReactNode;
+    } | {
+        data: T[];
+        renderItem: (item: T, index: number, info: {
+            isDragging: boolean;
+        }) => ReactNode;
+        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?: "label" | "normal";
+        divider?: boolean;
+        gap?: number;
+        colorScheme?: "primary" | "secondary";
+    }) & React__default.RefAttributes<IVirtualizedList>) => React__default.ReactElement | null;
+    const RowTitle: (props: {
+        className?: string;
+        children: React__default.ReactNode;
+    } & React__default.HTMLAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+    const EditableRowTitle: (props: EditableRowProps) => React__default.ReactElement | null;
+    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>;
+}
+
+declare const EDITOR_PANEL_GROUP_ID = "editor-panel-group";
+declare const LEFT_SIDEBAR_ID = "editor-left-sidebar";
+declare const RIGHT_SIDEBAR_ID = "editor-right-sidebar";
+declare const CONTENT_AREA_ID = "editor-content-area";
+type PanelLayoutState = {
+    leftSidebarCollapsed: boolean;
+    rightSidebarCollapsed: boolean;
+};
+declare function usePreservePanelSize(panelGroupRef: React__default.RefObject<ImperativePanelGroupHandle | null>, setPanelLayoutState?: (state: PanelLayoutState) => void): void;
+
+interface Props$1 {
+    autoSavePrefix?: string;
+    leftSidebarContent?: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    rightSidebarContent?: React__default.ReactNode;
+    hasRightSidebar?: boolean;
+    hasLeftSidebar?: boolean;
+    onChangeLayoutState?: (layoutState: PanelLayoutState) => void;
+    leftSidebarCanResize?: boolean;
+    id?: string;
+    className?: string;
+    style?: React__default.CSSProperties;
+    /**
+     * Accepts a number (px) or % string (e.g. "50%").
+     * Use % to avoid flicker server-rendering.
+     */
+    leftSidebarInitialSize?: number | string;
+    leftSidebarMinSize?: number | string;
+    /**
+     * Accepts a number (px) or % string (e.g. "50%").
+     * Use % to avoid flicker server-rendering.
+     */
+    rightSidebarInitialSize?: number | string;
+    rightSidebarMinSize?: number | string;
+}
+type IWorkspaceLayout = {
+    setLeftSidebarExpanded: (expanded: boolean) => void;
+    setRightSidebarExpanded: (expanded: boolean) => void;
+    toggleAllSidebars: () => void;
+    toggleLeftSidebar: () => void;
+    toggleRightSidebar: () => void;
+};
+declare const WorkspaceLayout: (props: Props$1 & React__default.RefAttributes<IWorkspaceLayout>) => React__default.ReactElement | null;
+
+type DesignSystemConfigurationContextValue = {
+    platform: PlatformName;
+};
+declare const DesignSystemConfigurationProvider: (props: {
+    children: ReactNode;
+    platform?: PlatformName;
+}) => React__default.ReactElement | null;
+declare function useDesignSystemConfiguration(): DesignSystemConfigurationContextValue;
+
+type DialogContextValue = {
+    openInputDialog(title: string, inputValue?: string): Promise<string | undefined>;
+    containsElement(element: HTMLElement): boolean;
+};
+declare const DialogProvider: ({ children, }: {
+    children: ReactNode;
+}) => React__default.JSX.Element;
+declare function useOpenInputDialog(): (title: string, inputValue?: string) => Promise<string | undefined>;
+declare function useDialogContainsElement(): (element: HTMLElement) => boolean;
+
+type FloatingWindowContextValue = {
+    createWindow: (element: React__default.ReactNode) => string;
+    closeWindow: (id: string) => void;
+};
+type CurrentWindowContextValue = {
+    id: string;
+};
+declare const FloatingWindowProvider: ({ children, }: {
+    children: React__default.ReactNode;
+}) => React__default.JSX.Element;
+declare const useFloatingWindowManager: () => FloatingWindowContextValue;
+declare const useCurrentFloatingWindowInternal: () => CurrentWindowContextValue;
+
+type ImageDataContextValue = {
+    getImageData: (ref: string) => ArrayBuffer | undefined;
+};
+declare const ImageDataProvider: (props: {
+    children: ReactNode;
+    getImageData?: (ref: string) => ArrayBuffer | undefined;
+}) => React__default.ReactElement | null;
+declare function useImageData(ref: string): ArrayBuffer | undefined;
+
+type GlobalInputBlurContextValue = {
+    addListener: (f: () => void) => void;
+    removeListener: (f: () => void) => void;
+    trigger: () => void;
+};
+declare const GlobalInputBlurProvider: React$1.Provider<GlobalInputBlurContextValue>;
+/**
+ * Some components store their editable state internally.
+ * We trigger this event before selection changes so that they can commit their
+ * edits before they unmount. This is more manual but simpler than doing so during
+ * the unmount phase (e.g. the return function of `useEffect`), since handlers are
+ * guaranteed to be called with the current data.
+ */
+declare const useGlobalInputBlur: () => GlobalInputBlurContextValue;
+declare function useGlobalInputBlurListener(f: () => void): void;
+declare function useGlobalInputBlurTrigger(): () => void;
+
+interface HoverEvent {
+    /** The type of hover event being fired. */
+    type: 'hoverstart' | 'hoverend';
+    /** The pointer type that triggered the hover event. */
+    pointerType: 'mouse' | 'pen';
+    /** The target element of the hover event. */
+    target: HTMLElement;
+}
+interface HoverEvents {
+    /** Handler that is called when a hover interaction starts. */
+    onHoverStart?(e: HoverEvent): void;
+    /** Handler that is called when a hover interaction ends. */
+    onHoverEnd?(e: HoverEvent): void;
+    /** Handler that is called when the hover state changes. */
+    onHoverChange?(isHovering: boolean): void;
+}
+interface HoverProps extends HoverEvents {
+    /** Whether the hover events should be disabled. */
+    isDisabled?: boolean;
+}
+interface HoverResult {
+    /** Props to spread on the target element. */
+    hoverProps: React$1.HTMLAttributes<HTMLElement>;
+    isHovered: boolean;
+}
+/**
+ * Handles pointer hover interactions for an element. Normalizes behavior
+ * across browsers and platforms, and ignores emulated mouse events on touch devices.
+ */
+declare function useHover(props?: HoverProps): HoverResult;
+
+declare function usePlatform(): _noya_app_noya_keymap.PlatformName;
+/**
+ * Either ctrl or meta, depending on the platform
+ */
+declare function usePlatformModKey(): 'ctrlKey' | 'metaKey';
+
+declare const size: {
+    medium: string;
+    large: string;
+    xlarge: string;
+    xxlarge: string;
+};
+declare const mediaQuery: {
+    small: string;
+    medium: string;
+    large: string;
+    xlarge: string;
+};
+
+type Optional<T> = T | false | null | undefined;
+type MenuConfig<T extends string> = Optional<Optional<RegularMenuItem<T>>[]>[];
+declare function createSectionedMenu<T extends string>(...sections: MenuConfig<T>): MenuItem<T>[];
+
+declare function getGradientBackground(value: Sketch.GradientStop[], type: Sketch.GradientType, direction?: number): string;
+
+declare function useDarkMode(elementRef: React.RefObject<HTMLElement>): {
+    isDark: boolean;
+    elementRef: React$1.RefObject<HTMLElement>;
+};
+
+declare function sketchColorToRgba(value: Sketch.Color): RgbaColor;
+declare function sketchColorToRgbaString(value: Sketch.Color): string;
+declare function rgbaToSketchColor(value: RgbaColor): Sketch.Color;
+declare function sketchColorToHex(value: Sketch.Color): string;
+
+declare function withSeparatorElements(elements: ReactNode, separator: ReactNode | (() => ReactNode)): (string | number | React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>> | Iterable<ReactNode> | React$1.ReactPortal)[];
+
+type SetNumberMode = "replace" | "adjust";
+declare function getNewValue(value: number, mode: SetNumberMode, delta?: number): number;
+type DimensionValue = number | undefined;
+interface Props {
+    id?: string;
+    value: DimensionValue;
+    onSetValue: (value: number, mode: SetNumberMode) => void;
+    label?: string;
+    size?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    trigger?: "change" | "submit";
+}
+declare const DimensionInput: (props: Props) => React__default.ReactElement | null;
+
+declare const Section: (props: React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+declare const SectionHeader: (props: React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+type TitleTextStyle = "small" | "heading5" | "heading4" | "heading3";
+declare const Title: (props: React__default.HTMLAttributes<HTMLDivElement> & {
+    $textStyle?: TitleTextStyle;
+} & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+declare const Row: (props: React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+declare const Column: (props: React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>) => React__default.ReactElement | null;
+declare const Checkbox: (props: React__default.InputHTMLAttributes<HTMLInputElement> & React__default.RefAttributes<HTMLInputElement>) => React__default.ReactElement | null;
+declare const Text: (props: React__default.HTMLAttributes<HTMLSpanElement> & React__default.RefAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+declare const VerticalSeparator: () => React__default.JSX.Element;
+declare const HorizontalSeparator: () => React__default.JSX.Element;
+declare const RowLabel: (props: React__default.HTMLAttributes<HTMLSpanElement> & {
+    $textStyle?: TitleTextStyle | "label";
+} & React__default.RefAttributes<HTMLSpanElement>) => React__default.ReactElement | null;
+interface LabeledRowProps {
+    id?: string;
+    children: ReactNode;
+    label: ReactNode;
+    labelTextStyle?: TitleTextStyle;
+    right?: ReactNode;
+    className?: string;
+}
+declare const LabeledRow: (props: LabeledRowProps) => React__default.ReactElement | null;
+
+declare const InspectorPrimitives_Checkbox: typeof Checkbox;
+declare const InspectorPrimitives_Column: typeof Column;
+declare const InspectorPrimitives_HorizontalSeparator: typeof HorizontalSeparator;
+declare const InspectorPrimitives_LabeledRow: typeof LabeledRow;
+declare const InspectorPrimitives_Row: typeof Row;
+declare const InspectorPrimitives_RowLabel: typeof RowLabel;
+declare const InspectorPrimitives_Section: typeof Section;
+declare const InspectorPrimitives_SectionHeader: typeof SectionHeader;
+declare const InspectorPrimitives_Text: typeof Text;
+declare const InspectorPrimitives_Title: typeof Title;
+declare const InspectorPrimitives_VerticalSeparator: typeof VerticalSeparator;
+declare namespace InspectorPrimitives {
+  export { InspectorPrimitives_Checkbox as Checkbox, InspectorPrimitives_Column as Column, InspectorPrimitives_HorizontalSeparator as HorizontalSeparator, InspectorPrimitives_LabeledRow as LabeledRow, InspectorPrimitives_Row as Row, InspectorPrimitives_RowLabel as RowLabel, InspectorPrimitives_Section as Section, InspectorPrimitives_SectionHeader as SectionHeader, InspectorPrimitives_Text as Text, InspectorPrimitives_Title as Title, InspectorPrimitives_VerticalSeparator as VerticalSeparator };
+}
+
+declare module "react" {
+    function memo<A, B>(Component: (props: A) => B): (props: A) => React.ReactElement | null;
+    function forwardRef<T, P = {}>(render: (props: P, ref: React.ForwardedRef<T>) => React.ReactElement | null): (props: P & React.RefAttributes<T>) => React.ReactElement | null;
+}
+
+export { ActivityIndicator, AutoResizingTextArea, Avatar, AvatarStack, Body, Button, type ButtonRootProps, CONTENT_AREA_ID, Chip, type ChipProps, type CompletionItem, type CompletionListItem, CompletionMenu, type CompletionSectionHeader, 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, InputFieldWithCompletions, type InputFieldWithCompletionsProps, type InputFieldWithCompletionsRef, InspectorContainer, InspectorPrimitives, Italic, KeyboardShortcut, LEFT_SIDEBAR_ID, Label, LabeledElementView, type ListRowMarginType, type ListRowPosition, ListView, type MatchRange, type MenuConfig, type MenuItem, type MenuItemProps, type MenuProps, type Optional, type PanelLayoutState, PatternPreviewBackground, Popover, Progress, RIGHT_SIDEBAR_ID, RadioGroup, type RegularMenuItem, type RelativeDropPosition, SEPARATOR_ITEM, SUPPORTED_CANVAS_UPLOAD_TYPES, SUPPORTED_IMAGE_UPLOAD_TYPES, ScrollArea, SelectMenu, type SetNumberMode, type SketchPattern, Slider, Small, Sortable, Spacer, type SupportedCanvasUploadType, type SupportedImageUploadType, Switch, Text$1 as Text, type TextProps, type Theme, type ThemeColor, Toast, ToastProvider, Tooltip, TreeView, WorkspaceLayout, cn, createSectionedMenu, fuzzyFilter, fuzzyScore, fuzzyTokenize, getGradientBackground, getNewValue, mediaQuery, normalizeListDestinationIndex, renderIcon, rgbaToSketchColor, size, sketchColorToHex, sketchColorToRgba, sketchColorToRgbaString, textStyles, useAutoResize, useCurrentFloatingWindowInternal, useDarkMode, useDesignSystemConfiguration, useDialogContainsElement, useFloatingWindowManager, useGlobalInputBlur, useGlobalInputBlurListener, useGlobalInputBlurTrigger, useHover, useImageData, useOpenInputDialog, usePlatform, usePlatformModKey, usePreservePanelSize, withSeparatorElements };