@zsviczian/excalidraw 0.17.6-30 → 0.17.6-31

package/types/excalidraw/components/Stats/CanvasGridSize.d.ts

@@ -0,0 +1,10 @@
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface PositionProps {
+    property: "gridSize";
+    scene: Scene;
+    appState: AppState;
+    setAppState: React.Component<any, AppState>["setState"];
+}
+declare const CanvasGridSize: ({ property, scene, appState, setAppState, }: PositionProps) => JSX.Element;
+export default CanvasGridSize;

package/types/excalidraw/components/Stats/Collapsible.d.ts

@@ -0,0 +1,9 @@
+interface CollapsibleProps {
+    label: React.ReactNode;
+    open: boolean;
+    openTrigger: () => void;
+    children: React.ReactNode;
+    className?: string;
+}
+declare const Collapsible: ({ label, open, openTrigger, children, className, }: CollapsibleProps) => JSX.Element;
+export default Collapsible;

package/types/excalidraw/components/Stats/Dimension.d.ts

@@ -0,0 +1,11 @@
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface DimensionDragInputProps {
+    property: "width" | "height";
+    element: ExcalidrawElement;
+    scene: Scene;
+    appState: AppState;
+}
+declare const DimensionDragInput: ({ property, element, scene, appState, }: DimensionDragInputProps) => JSX.Element;
+export default DimensionDragInput;

package/types/excalidraw/components/Stats/DragInput.d.ts

@@ -0,0 +1,34 @@
+import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { StatsInputProperty } from "./utils";
+import type Scene from "../../scene/Scene";
+import "./DragInput.scss";
+import type { AppState } from "../../types";
+export type DragInputCallbackType<P extends StatsInputProperty, E = ExcalidrawElement> = (props: {
+    accumulatedChange: number;
+    instantChange: number;
+    originalElements: readonly E[];
+    originalElementsMap: ElementsMap;
+    shouldKeepAspectRatio: boolean;
+    shouldChangeByStepSize: boolean;
+    scene: Scene;
+    nextValue?: number;
+    property: P;
+    originalAppState: AppState;
+    setInputValue: (value: number) => void;
+}) => void;
+interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElement> {
+    label: string | React.ReactNode;
+    icon?: React.ReactNode;
+    value: number | "Mixed";
+    elements: readonly E[];
+    editable?: boolean;
+    shouldKeepAspectRatio?: boolean;
+    dragInputCallback: DragInputCallbackType<T, E>;
+    property: T;
+    scene: Scene;
+    appState: AppState;
+    /** how many px you need to drag to get 1 unit change */
+    sensitivity?: number;
+}
+declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, sensitivity, }: StatsDragInputProps<T, E>) => JSX.Element | null;
+export default StatsDragInput;

package/types/excalidraw/components/Stats/FontSize.d.ts

@@ -0,0 +1,11 @@
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface FontSizeProps {
+    element: ExcalidrawElement;
+    scene: Scene;
+    appState: AppState;
+    property: "fontSize";
+}
+declare const FontSize: ({ element, scene, appState, property }: FontSizeProps) => JSX.Element | null;
+export default FontSize;

package/types/excalidraw/components/Stats/MultiAngle.d.ts

@@ -0,0 +1,11 @@
+import type { ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface MultiAngleProps {
+    elements: readonly ExcalidrawElement[];
+    scene: Scene;
+    appState: AppState;
+    property: "angle";
+}
+declare const MultiAngle: ({ elements, scene, appState, property, }: MultiAngleProps) => JSX.Element;
+export default MultiAngle;

package/types/excalidraw/components/Stats/MultiDimension.d.ts

@@ -0,0 +1,14 @@
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+import type { AtomicUnit } from "./utils";
+interface MultiDimensionProps {
+    property: "width" | "height";
+    elements: readonly ExcalidrawElement[];
+    elementsMap: NonDeletedSceneElementsMap;
+    atomicUnits: AtomicUnit[];
+    scene: Scene;
+    appState: AppState;
+}
+declare const MultiDimension: ({ property, elements, elementsMap, atomicUnits, scene, appState, }: MultiDimensionProps) => JSX.Element;
+export default MultiDimension;

package/types/excalidraw/components/Stats/MultiFontSize.d.ts

@@ -0,0 +1,12 @@
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface MultiFontSizeProps {
+    elements: readonly ExcalidrawElement[];
+    scene: Scene;
+    elementsMap: NonDeletedSceneElementsMap;
+    appState: AppState;
+    property: "fontSize";
+}
+declare const MultiFontSize: ({ elements, scene, appState, property, elementsMap, }: MultiFontSizeProps) => JSX.Element | null;
+export default MultiFontSize;

package/types/excalidraw/components/Stats/MultiPosition.d.ts

@@ -0,0 +1,14 @@
+import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AtomicUnit } from "./utils";
+import type { AppState } from "../../types";
+interface MultiPositionProps {
+    property: "x" | "y";
+    elements: readonly ExcalidrawElement[];
+    elementsMap: ElementsMap;
+    atomicUnits: AtomicUnit[];
+    scene: Scene;
+    appState: AppState;
+}
+declare const MultiPosition: ({ property, elements, elementsMap, atomicUnits, scene, appState, }: MultiPositionProps) => JSX.Element;
+export default MultiPosition;

package/types/excalidraw/components/Stats/Position.d.ts

@@ -0,0 +1,12 @@
+import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+interface PositionProps {
+    property: "x" | "y";
+    element: ExcalidrawElement;
+    elementsMap: ElementsMap;
+    scene: Scene;
+    appState: AppState;
+}
+declare const Position: ({ property, element, elementsMap, scene, appState, }: PositionProps) => JSX.Element;
+export default Position;

package/types/excalidraw/components/Stats/index.d.ts

@@ -0,0 +1,35 @@
+import type { NonDeletedExcalidrawElement } from "../../element/types";
+import type { AppClassProperties, AppState, ExcalidrawProps } from "../../types";
+import "./Stats.scss";
+interface StatsProps {
+    app: AppClassProperties;
+    onClose: () => void;
+    renderCustomStats: ExcalidrawProps["renderCustomStats"];
+}
+export declare const Stats: {
+    (props: StatsProps): JSX.Element;
+    StatsRow: {
+        ({ children, columns, heading, style, ...rest }: {
+            children: React.ReactNode;
+            columns?: number | undefined;
+            heading?: boolean | undefined;
+            style?: import("react").CSSProperties | undefined;
+        } & import("react").HTMLAttributes<HTMLDivElement>): JSX.Element;
+        displayName: string;
+    };
+    StatsRows: {
+        ({ children, order, style, ...rest }: {
+            children: React.ReactNode;
+            order?: number | undefined;
+            style?: import("react").CSSProperties | undefined;
+        } & import("react").HTMLAttributes<HTMLDivElement>): JSX.Element;
+        displayName: string;
+    };
+};
+export declare const StatsInner: import("react").MemoExoticComponent<({ app, onClose, renderCustomStats, selectedElements, appState, sceneNonce, gridModeEnabled, }: StatsProps & {
+    sceneNonce: number;
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+    appState: AppState;
+    gridModeEnabled: boolean;
+}) => JSX.Element>;
+export {};

package/types/excalidraw/components/Stats/utils.d.ts

@@ -0,0 +1,26 @@
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
+import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
+export type StatsInputProperty = "x" | "y" | "width" | "height" | "angle" | "fontSize" | "gridStep" | "gridSize";
+export declare const SMALLEST_DELTA = 0.01;
+export declare const isPropertyEditable: (element: ExcalidrawElement, property: keyof ExcalidrawElement) => boolean;
+export declare const getStepSizedValue: (value: number, stepSize: number) => number;
+export type AtomicUnit = Record<string, true>;
+export declare const getElementsInAtomicUnit: (atomicUnit: AtomicUnit, elementsMap: ElementsMap, originalElementsMap?: ElementsMap) => {
+    original: NonDeletedExcalidrawElement;
+    latest: NonDeletedExcalidrawElement;
+}[];
+export declare const newOrigin: (x1: number, y1: number, w1: number, h1: number, w2: number, h2: number, angle: number) => {
+    x: number;
+    y: number;
+};
+export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
+export declare const getAtomicUnits: (targetElements: readonly ExcalidrawElement[], appState: AppState) => AtomicUnit[];
+export declare const updateBindings: (latestElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    newSize?: {
+        width: number;
+        height: number;
+    };
+    zoom?: AppState["zoom"];
+}) => void;

package/types/excalidraw/components/Switch.d.ts

@@ -0,0 +1,9 @@
+import "./Switch.scss";
+export type SwitchProps = {
+    name: string;
+    checked: boolean;
+    title?: string;
+    onChange: (value: boolean) => void;
+    disabled?: boolean;
+};
+export declare const Switch: ({ title, name, checked, onChange, disabled, }: SwitchProps) => JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { NonDeletedExcalidrawElement } from "../../element/types";
+import "./MermaidToExcalidraw.scss";
+import type { MermaidToExcalidrawLibProps } from "./common";
+declare const MermaidToExcalidraw: ({ mermaidToExcalidrawLib, selectedElements, }: {
+    mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+}) => JSX.Element;
+export default MermaidToExcalidraw;

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

@@ -0,0 +1,10 @@
+import type { MermaidConfig } from "@zsviczian/mermaid-to-excalidraw";
+import type { ExcalidrawElement } from "../../element/types";
+import type { MermaidToExcalidrawLibProps } from "./common";
+export declare const loadMermaidToExcalidrawLib: () => Promise<MermaidToExcalidrawLibProps>;
+export declare const loadMermaidLib: () => Promise<MermaidToExcalidrawLibProps>;
+export declare const mermaidToExcalidraw: (mermaidDefinition: string, opts: MermaidConfig, forceSVG?: boolean) => Promise<{
+    elements?: ExcalidrawElement[];
+    files?: any;
+    error?: string;
+} | undefined>;

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

@@ -0,0 +1,29 @@
+import "./TTDDialog.scss";
+type OnTestSubmitRetValue = {
+    rateLimit?: number | null;
+    rateLimitRemaining?: number | null;
+} & ({
+    generatedResponse: string | undefined;
+    error?: null | undefined;
+} | {
+    error: Error;
+    generatedResponse?: null | undefined;
+});
+export declare const TTDDialog: (props: {
+    onTextSubmit(value: string): Promise<OnTestSubmitRetValue>;
+} | {
+    __fallback: true;
+}) => JSX.Element | null;
+/**
+ * Text to diagram (TTD) dialog
+ */
+export declare const TTDDialogBase: import("react").FC<({
+    tab: "text-to-diagram" | "mermaid";
+} & ({
+    onTextSubmit(value: string): Promise<OnTestSubmitRetValue>;
+} | {
+    __fallback: true;
+})) & {
+    __fallback?: boolean | undefined;
+}>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { ChangeEventHandler } from "react";
+interface TTDDialogInputProps {
+    input: string;
+    placeholder: string;
+    onChange: ChangeEventHandler<HTMLTextAreaElement>;
+    onKeyboardSubmit?: () => void;
+}
+export declare const TTDDialogInput: ({ input, placeholder, onChange, onKeyboardSubmit, }: TTDDialogInputProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+interface TTDDialogOutputProps {
+    error: Error | null;
+    canvasRef: React.RefObject<HTMLDivElement>;
+    loaded: boolean;
+}
+export declare const TTDDialogOutput: ({ error, canvasRef, loaded, }: TTDDialogOutputProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import type { ReactNode } from "react";
+interface TTDDialogPanelProps {
+    label: string;
+    children: ReactNode;
+    panelAction?: {
+        label: string;
+        action: () => void;
+        icon?: ReactNode;
+    };
+    panelActionDisabled?: boolean;
+    onTextSubmitInProgess?: boolean;
+    renderTopRight?: () => ReactNode;
+    renderSubmitShortcut?: () => ReactNode;
+    renderBottomRight?: () => ReactNode;
+}
+export declare const TTDDialogPanel: ({ label, children, panelAction, panelActionDisabled, onTextSubmitInProgess, renderTopRight, renderSubmitShortcut, renderBottomRight, }: TTDDialogPanelProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+export declare const TTDDialogPanels: ({ children }: {
+    children: ReactNode;
+}) => JSX.Element;

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

@@ -0,0 +1 @@
+export declare const TTDDialogSubmitShortcut: () => JSX.Element;

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

@@ -0,0 +1,7 @@
+export declare const TTDDialogTab: {
+    ({ tab, children, ...rest }: {
+        tab: string;
+        children: React.ReactNode;
+    } & import("react").HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,8 @@
+export declare const TTDDialogTabTrigger: {
+    ({ children, tab, onSelect, ...rest }: {
+        children: React.ReactNode;
+        tab: string;
+        onSelect?: React.ReactEventHandler<HTMLButtonElement> | undefined;
+    } & Omit<import("react").HTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,6 @@
+export declare const TTDDialogTabTriggers: {
+    ({ children, ...rest }: {
+        children: React.ReactNode;
+    } & import("react").HTMLAttributes<HTMLDivElement>): JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+declare const TTDDialogTabs: {
+    (props: {
+        children: ReactNode;
+    } & {
+        dialog: "ttd";
+        tab: "text-to-diagram" | "mermaid";
+    }): JSX.Element;
+    displayName: string;
+};
+export default TTDDialogTabs;

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

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+export declare const TTDDialogTrigger: {
+    ({ children, icon, }: {
+        children?: ReactNode;
+        icon?: JSX.Element | undefined;
+    }): JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,32 @@
+import type { MermaidConfig } from "@zsviczian/mermaid-to-excalidraw";
+import type { MermaidToExcalidrawResult } from "@zsviczian/mermaid-to-excalidraw/dist/interfaces";
+import type { NonDeletedExcalidrawElement } from "../../element/types";
+import type { AppClassProperties, BinaryFiles } from "../../types";
+export interface MermaidToExcalidrawLibProps {
+    loaded: boolean;
+    api: Promise<{
+        parseMermaidToExcalidraw: (definition: string, config?: MermaidConfig, forceSVG?: boolean) => Promise<MermaidToExcalidrawResult>;
+    }>;
+}
+interface ConvertMermaidToExcalidrawFormatProps {
+    canvasRef: React.RefObject<HTMLDivElement>;
+    mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
+    mermaidDefinition: string;
+    setError: (error: Error | null) => void;
+    data: React.MutableRefObject<{
+        elements: readonly NonDeletedExcalidrawElement[];
+        files: BinaryFiles | null;
+    }>;
+}
+export declare const convertMermaidToExcalidraw: ({ canvasRef, mermaidToExcalidrawLib, mermaidDefinition, setError, data, }: ConvertMermaidToExcalidrawFormatProps) => Promise<void>;
+export declare const saveMermaidDataToStorage: (mermaidDefinition: string) => void;
+export declare const insertToEditor: ({ app, data, text, shouldSaveMermaidDataToStorage, }: {
+    app: AppClassProperties;
+    data: React.MutableRefObject<{
+        elements: readonly NonDeletedExcalidrawElement[];
+        files: BinaryFiles | null;
+    }>;
+    text?: string | undefined;
+    shouldSaveMermaidDataToStorage?: boolean | undefined;
+}) => void;
+export {};

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

@@ -0,0 +1,21 @@
+import type { KeyboardEvent } from "react";
+import "./TextField.scss";
+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;
+} & ({
+    value: string;
+} | {
+    defaultValue: string;
+});
+export declare const TextField: import("react").ForwardRefExoticComponent<TextFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { CSSProperties } from "react";
+import "./Toast.scss";
+export declare const Toast: ({ message, onClose, closable, duration, style, }: {
+    message: string;
+    onClose: () => void;
+    closable?: boolean | undefined;
+    duration?: number | undefined;
+    style?: CSSProperties | undefined;
+}) => JSX.Element;

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

@@ -0,0 +1,49 @@
+import "./ToolIcon.scss";
+import type { CSSProperties } from "react";
+import React from "react";
+import type { PointerType } from "../element/types";
+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/types/excalidraw/components/Tooltip.d.ts

@@ -0,0 +1,18 @@
+import "./Tooltip.scss";
+import React from "react";
+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) => JSX.Element | null;
+export {};

package/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 }: {
+    [key: string]: React.ReactNode | ((el: React.ReactNode) => React.ReactNode);
+    i18nKey: TranslationKeys;
+}) => React.FunctionComponentElement<{
+    children?: React.ReactNode;
+}>;
+export default Trans;

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

@@ -0,0 +1,18 @@
+import "./UserList.scss";
+import React from "react";
+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) => JSX.Element>;
+export {};

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

@@ -0,0 +1,29 @@
+import React from "react";
+import type { DOMAttributes } from "react";
+import type { Device, InteractiveCanvasAppState } from "../../types";
+import type { RenderableElementsMap, RenderInteractiveSceneCallback } from "../../scene/types";
+import type { NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
+type InteractiveCanvasProps = {
+    containerRef: React.RefObject<HTMLDivElement>;
+    canvas: HTMLCanvasElement | null;
+    elementsMap: RenderableElementsMap;
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    selectedElements: readonly NonDeletedExcalidrawElement[];
+    allElementsMap: NonDeletedSceneElementsMap;
+    sceneNonce: number | undefined;
+    selectionNonce: number | undefined;
+    scale: number;
+    appState: InteractiveCanvasAppState;
+    device: Device;
+    renderInteractiveSceneCallback: (data: RenderInteractiveSceneCallback) => void;
+    handleCanvasRef: (canvas: HTMLCanvasElement | null) => void;
+    onContextMenu: Exclude<DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"], 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>;
+};
+declare const _default: React.MemoExoticComponent<(props: InteractiveCanvasProps) => JSX.Element>;
+export default _default;

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

@@ -0,0 +1,14 @@
+import type { NonDeletedSceneElementsMap } from "../../element/types";
+import type { AppState } from "../../types";
+import type { RenderableElementsMap, StaticCanvasRenderConfig } from "../../scene/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) => JSX.Element;
+export default NewElementCanvas;

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

@@ -0,0 +1,19 @@
+import React from "react";
+import type { RoughCanvas } from "roughjs/bin/canvas";
+import type { StaticCanvasAppState } from "../../types";
+import type { RenderableElementsMap, StaticCanvasRenderConfig } from "../../scene/types";
+import type { NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
+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) => JSX.Element>;
+export default _default;

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

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