@nous-excalidraw/element 0.18.0-cy.1

package/dist/types/excalidraw/components/TTDDialog/types.d.ts

@@ -0,0 +1,95 @@
+import type { RequestError } from "@excalidraw/excalidraw/errors";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { MermaidConfig } from "@excalidraw/mermaid-to-excalidraw";
+import type { MermaidToExcalidrawResult } from "@excalidraw/mermaid-to-excalidraw/dist/interfaces";
+import type { BinaryFiles } from "../../types";
+export type LLMMessage = {
+    role: "user" | "assistant";
+    content: string;
+};
+export type MermaidData = {
+    elements: readonly NonDeletedExcalidrawElement[];
+    files: BinaryFiles | null;
+};
+export interface RateLimits {
+    rateLimit: number;
+    rateLimitRemaining: number;
+}
+export declare namespace TChat {
+    type ChatMessage = {
+        id: string;
+        timestamp: Date;
+        isGenerating?: boolean;
+        error?: string;
+        errorDetails?: string;
+        errorType?: "parse" | "network" | "other";
+        lastAttemptAt?: number;
+        type: "user" | "assistant" | "warning";
+        warningType?: /* daily rate limit */ "messageLimitExceeded" | /* general 429 */ "rateLimitExceeded";
+        content?: string;
+    };
+    type ChatHistory = {
+        id: string;
+        messages: ChatMessage[];
+        currentPrompt: string;
+    };
+}
+export interface SavedChat {
+    id: string;
+    title: string;
+    messages: TChat.ChatMessage[];
+    currentPrompt: string;
+    timestamp: number;
+}
+export type SavedChats = SavedChat[];
+/**
+ * Interface for TTD chat persistence. Preferably should be stable
+ * (e.g. static class/singleton)
+ */
+export interface TTDPersistenceAdapter {
+    /**
+     * Load saved chats from storage.
+     */
+    loadChats(): Promise<SavedChats>;
+    /**
+     * Save chats to storage.
+     */
+    saveChats(chats: SavedChats): Promise<void>;
+}
+export interface MermaidToExcalidrawLibProps {
+    loaded: boolean;
+    api: Promise<{
+        parseMermaidToExcalidraw: (definition: string, config?: MermaidConfig) => Promise<MermaidToExcalidrawResult>;
+    }>;
+}
+export declare namespace TTTDDialog {
+    type OnGenerate = (opts: {
+        prompt: string;
+        isRepairFlow?: boolean;
+    }) => Promise<void>;
+    type OnTextSubmitProps = {
+        messages: LLMMessage[];
+        onChunk?: (chunk: string) => void;
+        onStreamCreated?: () => void;
+        signal?: AbortSignal;
+    };
+    type OnTextSubmitRetValue = {
+        rateLimit?: number | null;
+        rateLimitRemaining?: number | null;
+    } & ({
+        generatedResponse: string;
+        error: null;
+    } | {
+        error: RequestError;
+        generatedResponse?: null;
+    });
+    type onTextSubmit = (props: OnTextSubmitProps) => Promise<OnTextSubmitRetValue>;
+    /**
+     * return undefined to use default rendering
+     */
+    type renderWarning = (chatMessage: TChat.ChatMessage) => React.ReactNode | undefined;
+    type renderWelcomeScreen = (props: {
+        /** null if not rate limit data currently available */
+        rateLimits: RateLimits | null;
+    }) => React.ReactNode | undefined;
+}

package/dist/types/excalidraw/components/TTDDialog/useTTDChatStorage.d.ts

@@ -0,0 +1,22 @@
+import type { SavedChat, SavedChats, TTDPersistenceAdapter } from "./types";
+interface UseTTDChatStorageProps {
+    persistenceAdapter: TTDPersistenceAdapter;
+}
+interface UseTTDChatStorageReturn {
+    savedChats: SavedChats;
+    saveCurrentChat: () => Promise<void>;
+    deleteChat: (chatId: string) => Promise<SavedChats>;
+    restoreChat: (chat: SavedChat) => SavedChat;
+    createNewChatId: () => Promise<string>;
+}
+export declare const savedChatsAtom: import("jotai/vanilla/atom").PrimitiveAtom<SavedChats> & {
+    init: SavedChats;
+};
+export declare const isLoadingChatsAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const chatsLoadedAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const useTTDChatStorage: ({ persistenceAdapter, }: UseTTDChatStorageProps) => UseTTDChatStorageReturn;
+export {};

package/dist/types/excalidraw/components/TTDDialog/utils/chat.d.ts

@@ -0,0 +1,10 @@
+import type { LLMMessage, TChat } from "../types";
+export declare const updateAssistantContent: (chatHistory: TChat.ChatHistory, payload: Partial<TChat.ChatMessage>) => TChat.ChatHistory;
+export declare const getLastAssistantMessage: (chatHistory: TChat.ChatHistory) => TChat.ChatMessage;
+export declare const addMessages: (chatHistory: TChat.ChatHistory, messages: Array<Omit<TChat.ChatMessage, "id" | "timestamp">>) => {
+    messages: TChat.ChatMessage[];
+    id: string;
+    currentPrompt: string;
+};
+export declare const removeLastAssistantMessage: (chatHistory: TChat.ChatHistory) => TChat.ChatHistory;
+export declare const getMessagesForLLM: (chatHistory: TChat.ChatHistory) => LLMMessage[];

package/dist/types/excalidraw/components/TTDDialog/utils/mermaidAutoFix.d.ts

@@ -0,0 +1 @@
+export declare const getMermaidAutoFixCandidates: (sourceText: string, errorMessage: string) => string[];

package/dist/types/excalidraw/components/TTDDialog/utils/mermaidError.d.ts

@@ -0,0 +1,10 @@
+export declare const isMermaidParseSyntaxError: (message: string) => boolean;
+export declare const isMermaidAutoFixableError: (message: string) => boolean;
+export declare const isMermaidCaretLine: (line: string) => boolean;
+export declare const getMermaidInactiveParticipant: (message: string) => string | null;
+export declare const getMermaidErrorLineNumber: (message: string, sourceText?: string) => number | null;
+export declare const getMermaidSyntaxErrorGuidance: (message: string, sourceText?: string) => {
+    summary: string;
+    likelyCauses: string[];
+} | null;
+export declare const formatMermaidParseErrorMessage: (message: string) => string;

package/dist/types/excalidraw/components/TTDDialog/utils/mermaidValidation.d.ts

@@ -0,0 +1 @@
+export declare const isValidMermaidSyntax: (content: string) => boolean;

package/dist/types/excalidraw/components/TextField.d.ts

@@ -0,0 +1,22 @@
+import "./TextField.scss";
+import type { KeyboardEvent } from "react";
+type TextFieldProps = {
+    onChange?: (value: string) => void;
+    onClick?: () => void;
+    onKeyDown?: (event: KeyboardEvent<HTMLInputElement>) => void;
+    readonly?: boolean;
+    fullWidth?: boolean;
+    selectOnRender?: boolean;
+    icon?: React.ReactNode;
+    label?: string;
+    className?: string;
+    placeholder?: string;
+    isRedacted?: boolean;
+    type?: "text" | "search";
+} & ({
+    value: string;
+} | {
+    defaultValue: string;
+});
+export declare const TextField: import("react").ForwardRefExoticComponent<TextFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+export {};

package/dist/types/excalidraw/components/Toast.d.ts

@@ -0,0 +1,13 @@
+import "./Toast.scss";
+import type { CSSProperties, ReactNode } from "react";
+export declare const Toast: (({ message, onClose, closable, duration, style, }: {
+    message: ReactNode;
+    onClose: () => void;
+    closable?: boolean;
+    duration?: number;
+    style?: CSSProperties;
+}) => import("react/jsx-runtime").JSX.Element) & {
+    ProgressBar: ({ progress }: {
+        progress: number;
+    }) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/types/excalidraw/components/ToolButton.d.ts

@@ -0,0 +1,49 @@
+import React from "react";
+import type { PointerType } from "@excalidraw/element/types";
+import "./ToolIcon.scss";
+import type { CSSProperties } from "react";
+export type ToolButtonSize = "small" | "medium";
+type ToolButtonBaseProps = {
+    icon?: React.ReactNode;
+    "aria-label": string;
+    "aria-keyshortcuts"?: string;
+    "data-testid"?: string;
+    label?: string;
+    title?: string;
+    name?: string;
+    id?: string;
+    size?: ToolButtonSize;
+    keyBindingLabel?: string | null;
+    showAriaLabel?: boolean;
+    hidden?: boolean;
+    visible?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    isLoading?: boolean;
+};
+type ToolButtonProps = (ToolButtonBaseProps & {
+    type: "button";
+    children?: React.ReactNode;
+    onClick?(event: React.MouseEvent): void;
+}) | (ToolButtonBaseProps & {
+    type: "submit";
+    children?: React.ReactNode;
+    onClick?(event: React.MouseEvent): void;
+}) | (ToolButtonBaseProps & {
+    type: "icon";
+    children?: React.ReactNode;
+    onClick?(): void;
+}) | (ToolButtonBaseProps & {
+    type: "radio";
+    checked: boolean;
+    onChange?(data: {
+        pointerType: PointerType | null;
+    }): void;
+    onPointerDown?(data: {
+        pointerType: PointerType;
+    }): void;
+});
+export declare const ToolButton: React.ForwardRefExoticComponent<ToolButtonProps & React.RefAttributes<unknown>>;
+export {};

package/dist/types/excalidraw/components/ToolPopover.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./ToolPopover.scss";
+import type { AppClassProperties } from "../types";
+type ToolOption = {
+    type: string;
+    icon: React.ReactNode;
+    title?: string;
+};
+type ToolPopoverProps = {
+    app: AppClassProperties;
+    options: readonly ToolOption[];
+    activeTool: {
+        type: string;
+    };
+    defaultOption: string;
+    className?: string;
+    namePrefix: string;
+    title: string;
+    "data-testid": string;
+    onToolChange: (type: string) => void;
+    displayedOption: ToolOption;
+    fillable?: boolean;
+};
+export declare const ToolPopover: ({ app, options, activeTool, defaultOption, className, namePrefix, title, "data-testid": dataTestId, onToolChange, displayedOption, fillable, }: ToolPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/excalidraw/components/Tooltip.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./Tooltip.scss";
+export declare const getTooltipDiv: () => HTMLDivElement;
+export declare const updateTooltipPosition: (tooltip: HTMLDivElement, item: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, position?: "bottom" | "top") => void;
+type TooltipProps = {
+    children: React.ReactNode;
+    label: string;
+    long?: boolean;
+    style?: React.CSSProperties;
+    disabled?: boolean;
+};
+export declare const Tooltip: ({ children, label, long, style, disabled, }: TooltipProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/excalidraw/components/Trans.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { TranslationKeys } from "../i18n";
+declare const Trans: ({ i18nKey, children, ...props }: {
+    i18nKey: TranslationKeys;
+    [key: string]: React.ReactNode | ((el: React.ReactNode) => React.ReactNode);
+}) => React.FunctionComponentElement<{
+    children?: React.ReactNode | undefined;
+}>;
+export default Trans;

package/dist/types/excalidraw/components/UnlockPopup.d.ts

@@ -0,0 +1,8 @@
+import "./UnlockPopup.scss";
+import type App from "./App";
+import type { AppState } from "../types";
+declare const UnlockPopup: ({ app, activeLockedId, }: {
+    app: App;
+    activeLockedId: NonNullable<AppState["activeLockedId"]>;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default UnlockPopup;

package/dist/types/excalidraw/components/UserList.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./UserList.scss";
+import type { Collaborator, SocketId } from "../types";
+export type GoToCollaboratorComponentProps = {
+    socketId: SocketId;
+    collaborator: Collaborator;
+    withName: boolean;
+    isBeingFollowed: boolean;
+};
+type UserListUserObject = Pick<Collaborator, "avatarUrl" | "id" | "socketId" | "username" | "isInCall" | "isSpeaking" | "isMuted">;
+type UserListProps = {
+    className?: string;
+    mobile?: boolean;
+    collaborators: Map<SocketId, UserListUserObject>;
+    userToFollow: SocketId | null;
+};
+export declare const UserList: React.MemoExoticComponent<({ className, mobile, collaborators, userToFollow }: UserListProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/types/excalidraw/components/canvases/InteractiveCanvas.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+import { type EditorInterface } from "@excalidraw/common";
+import type { RenderableElementsMap, RenderInteractiveSceneCallback } from "@excalidraw/excalidraw/scene/types";
+import type { NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { AppClassProperties, InteractiveCanvasAppState } from "../../types";
+import type { DOMAttributes } from "react";
+type InteractiveCanvasProps = {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    canvas: HTMLCanvasElement | null;
+    elementsMap: RenderableElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+    allElementsMap: NonDeletedSceneElementsMap;
+    sceneNonce: number | undefined;
+    selectionNonce: number | undefined;
+    scale: number;
+    appState: InteractiveCanvasAppState;
+    renderScrollbars: boolean;
+    editorInterface: EditorInterface;
+    app: AppClassProperties;
+    renderInteractiveSceneCallback: (data: RenderInteractiveSceneCallback) => void;
+    handleCanvasRef: (canvas: HTMLCanvasElement | null) => void;
+    onContextMenu: Exclude<DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"], undefined>;
+    onClick: Exclude<DOMAttributes<HTMLCanvasElement>["onClick"], undefined>;
+    onPointerMove: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerMove"], undefined>;
+    onPointerUp: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerUp"], undefined>;
+    onPointerCancel: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerCancel"], undefined>;
+    onTouchMove: Exclude<DOMAttributes<HTMLCanvasElement>["onTouchMove"], undefined>;
+    onPointerDown: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerDown"], undefined>;
+    onDoubleClick: Exclude<DOMAttributes<HTMLCanvasElement>["onDoubleClick"], undefined>;
+};
+export declare const INTERACTIVE_SCENE_ANIMATION_KEY = "animateInteractiveScene";
+declare const _default: React.MemoExoticComponent<(props: InteractiveCanvasProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/types/excalidraw/components/canvases/NewElementCanvas.d.ts

@@ -0,0 +1,14 @@
+import type { NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { RenderableElementsMap, StaticCanvasRenderConfig } from "../../scene/types";
+import type { AppState } from "../../types";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+interface NewElementCanvasProps {
+    appState: AppState;
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
+    scale: number;
+    rc: RoughCanvas;
+    renderConfig: StaticCanvasRenderConfig;
+}
+declare const NewElementCanvas: (props: NewElementCanvasProps) => import("react/jsx-runtime").JSX.Element;
+export default NewElementCanvas;

package/dist/types/excalidraw/components/canvases/StaticCanvas.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import type { NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { RenderableElementsMap, StaticCanvasRenderConfig } from "../../scene/types";
+import type { StaticCanvasAppState } from "../../types";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+type StaticCanvasProps = {
+    canvas: HTMLCanvasElement;
+    rc: RoughCanvas;
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    sceneNonce: number | undefined;
+    selectionNonce: number | undefined;
+    scale: number;
+    appState: StaticCanvasAppState;
+    renderConfig: StaticCanvasRenderConfig;
+};
+declare const _default: React.MemoExoticComponent<(props: StaticCanvasProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/types/excalidraw/components/canvases/index.d.ts

@@ -0,0 +1,3 @@
+import InteractiveCanvas from "./InteractiveCanvas";
+import StaticCanvas from "./StaticCanvas";
+export { InteractiveCanvas, StaticCanvas };

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenu.d.ts

@@ -0,0 +1,98 @@
+import React from "react";
+import "./DropdownMenu.scss";
+declare const DropdownMenu: {
+    ({ children, open, }: {
+        children?: React.ReactNode;
+        open: boolean;
+    }): import("react/jsx-runtime").JSX.Element;
+    Trigger: {
+        ({ className, children, onToggle, title, ...rest }: {
+            className?: string;
+            children: React.ReactNode;
+            onToggle: () => void;
+            title?: string;
+        } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ children, onClickOutside, className, onSelect, open, align, style, }: {
+            children?: React.ReactNode;
+            onClickOutside?: () => void;
+            className?: string;
+            onSelect?: (event: Event) => void;
+            open?: boolean;
+            style?: React.CSSProperties;
+            align?: "start" | "center" | "end";
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        ({ icon, badge, value, children, shortcut, className, selected, onSelect, ...rest }: import("./DropdownMenuItem").DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+        Badge: {
+            ({ type, children, }: {
+                type?: import("@excalidraw/common/utility-types").ValueOf<typeof import("./DropdownMenuItem").DropDownMenuItemBadgeType>;
+                children: React.ReactNode;
+            }): import("react/jsx-runtime").JSX.Element;
+            displayName: string;
+        };
+    };
+    ItemCheckbox: (props: Omit<import("./DropdownMenuItem").DropdownMenuItemProps, "icon"> & {
+        checked: boolean;
+    }) => import("react/jsx-runtime").JSX.Element;
+    ItemLink: {
+        ({ icon, shortcut, href, children, onSelect, className, selected, rel, ...rest }: {
+            href: string;
+            icon?: React.JSX.Element;
+            children: React.ReactNode;
+            shortcut?: string;
+            className?: string;
+            selected?: boolean;
+            onSelect?: (event: Event) => void;
+            rel?: string;
+        } & React.AnchorHTMLAttributes<HTMLAnchorElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    ItemCustom: ({ children, className, selected, ...rest }: {
+        children: React.ReactNode;
+        className?: string;
+        selected?: boolean;
+    } & React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+    Group: {
+        ({ children, className, style, title, }: {
+            children: React.ReactNode;
+            className?: string;
+            style?: React.CSSProperties;
+            title?: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Separator: {
+        (): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Sub: {
+        ({ children }: {
+            children?: React.ReactNode;
+        }): import("react/jsx-runtime").JSX.Element;
+        Trigger: {
+            ({ children, icon, shortcut, className, }: {
+                children: React.ReactNode;
+                icon?: React.JSX.Element;
+                shortcut?: string;
+                className?: string;
+            }): import("react/jsx-runtime").JSX.Element;
+            displayName: string;
+        };
+        Content: {
+            ({ children, className, }: {
+                children?: React.ReactNode;
+                className?: string;
+            }): import("react/jsx-runtime").JSX.Element;
+            displayName: string;
+        };
+        displayName: string;
+    };
+    displayName: string;
+};
+export default DropdownMenu;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuContent.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+declare const MenuContent: {
+    ({ children, onClickOutside, className, onSelect, open, align, style, }: {
+        children?: React.ReactNode;
+        onClickOutside?: () => void;
+        className?: string;
+        /**
+         * Called when any menu item is selected (clicked on).
+         */
+        onSelect?: (event: Event) => void;
+        open?: boolean;
+        style?: React.CSSProperties;
+        align?: "start" | "center" | "end";
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MenuContent;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuGroup.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+declare const MenuGroup: {
+    ({ children, className, style, title, }: {
+        children: React.ReactNode;
+        className?: string;
+        style?: React.CSSProperties;
+        title?: string;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MenuGroup;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItem.d.ts

@@ -0,0 +1,37 @@
+import React from "react";
+import type { ValueOf } from "@excalidraw/common/utility-types";
+import type { JSX } from "react";
+export type DropdownMenuItemProps = {
+    icon?: JSX.Element;
+    badge?: React.ReactNode;
+    value?: string | number | undefined;
+    onSelect?: (event: Event) => void;
+    children: React.ReactNode;
+    shortcut?: string;
+    selected?: boolean;
+    className?: string;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">;
+declare const DropdownMenuItem: {
+    ({ icon, badge, value, children, shortcut, className, selected, onSelect, ...rest }: DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+    Badge: {
+        ({ type, children, }: {
+            type?: ValueOf<typeof DropDownMenuItemBadgeType>;
+            children: React.ReactNode;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export declare const DropDownMenuItemBadgeType: {
+    readonly GREEN: "green";
+    readonly RED: "red";
+    readonly BLUE: "blue";
+};
+export declare const DropDownMenuItemBadge: {
+    ({ type, children, }: {
+        type?: ValueOf<typeof DropDownMenuItemBadgeType>;
+        children: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default DropdownMenuItem;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItemCheckbox.d.ts

@@ -0,0 +1,5 @@
+import type { DropdownMenuItemProps } from "./DropdownMenuItem";
+declare const DropdownMenuItemCheckbox: (props: Omit<DropdownMenuItemProps, "icon"> & {
+    checked: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default DropdownMenuItemCheckbox;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItemContent.d.ts

@@ -0,0 +1,9 @@
+import type { JSX } from "react";
+declare const MenuItemContent: ({ textStyle, icon, shortcut, children, badge, }: {
+    icon?: JSX.Element;
+    shortcut?: string;
+    textStyle?: React.CSSProperties;
+    children: React.ReactNode;
+    badge?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default MenuItemContent;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.d.ts

@@ -0,0 +1,18 @@
+type Props<T> = {
+    value: T;
+    shortcut?: string;
+    choices: {
+        value: T;
+        label: React.ReactNode;
+        ariaLabel?: string;
+    }[];
+    onChange: (value: T) => void;
+    children: React.ReactNode;
+    name: string;
+    icon?: React.ReactNode;
+};
+declare const DropdownMenuItemContentRadio: {
+    <T>({ value, shortcut, onChange, choices, children, name, icon, }: Props<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default DropdownMenuItemContentRadio;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItemCustom.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+declare const DropdownMenuItemCustom: ({ children, className, selected, ...rest }: {
+    children: React.ReactNode;
+    className?: string;
+    selected?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
+export default DropdownMenuItemCustom;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItemLink.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import type { JSX } from "react";
+declare const DropdownMenuItemLink: {
+    ({ icon, shortcut, href, children, onSelect, className, selected, rel, ...rest }: {
+        href: string;
+        icon?: JSX.Element;
+        children: React.ReactNode;
+        shortcut?: string;
+        className?: string;
+        selected?: boolean;
+        onSelect?: (event: Event) => void;
+        rel?: string;
+    } & React.AnchorHTMLAttributes<HTMLAnchorElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default DropdownMenuItemLink;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuSeparator.d.ts

@@ -0,0 +1,5 @@
+declare const MenuSeparator: {
+    (): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MenuSeparator;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuSub.d.ts

@@ -0,0 +1,23 @@
+declare const DropdownMenuSub: {
+    ({ children }: {
+        children?: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    Trigger: {
+        ({ children, icon, shortcut, className, }: {
+            children: React.ReactNode;
+            icon?: import("react").JSX.Element;
+            shortcut?: string;
+            className?: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ children, className, }: {
+            children?: React.ReactNode;
+            className?: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    displayName: string;
+};
+export default DropdownMenuSub;