@orangecatai/element 0.0.1 → 0.0.3

package/dist/types/excalidraw/components/ai-chat/htmlToExcalidraw.d.ts

@@ -0,0 +1,53 @@
+export type ParsedRectangle = {
+    kind: "rectangle";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    backgroundGradient?: string;
+    strokeColor: string;
+    strokeWidth: number;
+    opacity: number;
+    borderRadius: number;
+};
+export type ParsedEllipse = {
+    kind: "ellipse";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    backgroundGradient?: string;
+    strokeColor: string;
+    strokeWidth: number;
+    opacity: number;
+};
+export type ParsedText = {
+    kind: "text";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    fontSize: number;
+    fontFamily: number;
+    color: string;
+    textAlign: "left" | "center" | "right";
+    opacity: number;
+};
+export type ParsedImage = {
+    kind: "image";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    dataUrl: string;
+};
+export type ParsedElement = ParsedRectangle | ParsedEllipse | ParsedText | ParsedImage;
+/**
+ * Render `html` in an off-screen iframe and walk the DOM to produce an
+ * array of ParsedElement objects, translated so the root .canvas div sits
+ * at (frameX, frameY) in Excalidraw canvas coordinates.
+ */
+export declare function htmlToExcalidrawElements(html: string, frameX: number, frameY: number, frameWidth: number, frameHeight: number, customFontMap?: Record<string, number>): Promise<ParsedElement[]>;

package/dist/types/excalidraw/components/ai-chat/openRouterStream.d.ts

@@ -0,0 +1,50 @@
+import type { ToolCall } from "./agentLoop";
+export type OpenRouterDelta = {
+    content: string | null;
+    toolCalls: Array<{
+        index: number;
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }> | null;
+    finishReason: string | null;
+};
+export type ToolCallAccumulator = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+/**
+ * Parse a single OpenAI-compatible SSE chunk JSON string into a typed delta.
+ * Returns null if the JSON is invalid or missing expected structure.
+ */
+export declare function parseOpenRouterChunk(jsonStr: string): OpenRouterDelta | null;
+/**
+ * Async generator that yields parsed deltas from an OpenRouter streaming
+ * response. Reuses `parseSSEStream` for SSE line parsing.
+ */
+export declare function streamOpenRouter(response: Response): AsyncGenerator<OpenRouterDelta>;
+/**
+ * Accumulate streaming tool call deltas into complete ToolCall objects.
+ * OpenRouter sends tool calls in chunks:
+ *   - First chunk for a tool: has `id`, `type`, `function.name`, empty `function.arguments`
+ *   - Subsequent chunks: has `function.arguments` fragment to append
+ */
+export declare function accumulateToolCalls(accumulated: ToolCallAccumulator[], delta: OpenRouterDelta): ToolCallAccumulator[];
+/**
+ * Convert accumulators to the ToolCall type used by the agent loop.
+ */
+export declare function finalizeToolCalls(accumulated: ToolCallAccumulator[]): ToolCall[];
+/**
+ * Check if a response is a streaming SSE response.
+ * Returns true only when the response has a body AND the content-type
+ * indicates an SSE stream (`text/event-stream`). Any other content-type
+ * (including `application/json` or `text/plain`) falls back to non-streaming.
+ */
+export declare function isStreamingResponse(response: Response): boolean;

package/dist/types/excalidraw/components/ai-chat/reviewerAgent.d.ts

@@ -0,0 +1,64 @@
+/**
+ * reviewerAgent.ts
+ *
+ * Stateless reviewer module. After generate_html_banner succeeds, this
+ * agent receives a partial, focused context (rendered screenshot, HTML
+ * source, frame dimensions, brand guidelines, original user brief) and
+ * returns precise layout/readability critique — NOT the full agent
+ * conversation history.
+ *
+ * The reviewer is a separate LLM call from the main agent loop so it
+ * brings an independent eye to the generated banner.
+ */
+import type { BrandContext } from "../../types";
+export type ReviewIssue = {
+    /** Which design element is affected */
+    element: "headline" | "subheadline" | "cta" | "image" | "layout" | "brand";
+    /** How bad it is */
+    severity: "critical" | "major" | "minor";
+    /** What is wrong — one sentence */
+    problem: string;
+    /** One-line direction for the fix */
+    fix: string;
+    /**
+     * Precise instruction with numeric coordinates or px values.
+     * Examples:
+     *   "Reduce headline font-size from 72px to 48px"
+     *   "Move CTA button to x=380,y=440 (bottom-right quadrant)"
+     *   "Shift text container left boundary from x=0 to x=20 so it clears the image at x=260"
+     */
+    preciseInstruction: string;
+};
+export type ReviewerFeedback = {
+    /** true = no actionable issues; main agent should finalize */
+    approved: boolean;
+    /** empty when approved */
+    issues: ReviewIssue[];
+    /** 1-2 sentence overall verdict */
+    summary: string;
+    /** which reviewer round produced this (1-based) */
+    iteration: number;
+};
+export declare function runReviewerAgent(opts: {
+    screenshotDataUrl: string;
+    htmlSource: string;
+    frame: {
+        width: number;
+        height: number;
+        id: string;
+    };
+    imagePlacement?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Original user request — first message only, not full conversation history */
+    userBrief: string;
+    brandContext?: BrandContext;
+    apiKey: string;
+    /** OpenRouter model tag. Must be vision-capable. Defaults to gemini-3.1-flash-lite-preview */
+    reviewerModel?: string;
+    signal?: AbortSignal;
+    iteration: number;
+}): Promise<ReviewerFeedback>;

package/dist/types/excalidraw/components/auto-resize/AutoResizePanel.d.ts

@@ -0,0 +1,17 @@
+import "./AutoResizePanel.scss";
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
+import type { AppClassProperties } from "../../types";
+export declare const AutoResizePanel: ({ element, app, onClose, onBeforeAutoResize, onAfterAutoResize, onRunningChange, openRouterApiKey, chatModel, agentImageModel, }: {
+    element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement;
+    app: AppClassProperties;
+    onClose: () => void;
+    onBeforeAutoResize?: () => Promise<{
+        allowed: boolean;
+        error?: string;
+    }>;
+    onAfterAutoResize?: () => void;
+    onRunningChange?: (running: boolean) => void;
+    openRouterApiKey: string;
+    chatModel: string;
+    agentImageModel?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/auto-resize/AutoResizePanelHost.d.ts

@@ -0,0 +1,4 @@
+import type { AppClassProperties } from "../../types";
+export declare const AutoResizePanelHost: ({ app }: {
+    app: AppClassProperties;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/excalidraw/components/auto-resize/AutoResizeShimmerLayer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Renders shimmer overlays on top of in-progress auto-resize frames.
+ * Rendered unconditionally from App.tsx — same React tree as FrameToolbar
+ * and ElementCanvasButtons. Uses useExcalidrawAppState() for reactive
+ * viewport state (scroll, zoom, offset) so it repositions on every change.
+ *
+ * IMPORTANT: Reads the CURRENT frame position from the scene elements,
+ * not from the stored LoadingFrameInfo. This ensures the shimmer moves
+ * with the frame if the user drags it during generation.
+ */
+export declare const AutoResizeShimmerLayer: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/excalidraw/components/auto-resize/autoResizeEngine.d.ts

@@ -0,0 +1,144 @@
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement } from "@orangecatai/element/types";
+import type { AppClassProperties } from "../../types";
+import type { BinaryFiles } from "../../types";
+export type TargetDimension = {
+    width: number;
+    height: number;
+    label?: string;
+};
+export type DimensionResult = {
+    status: "ok";
+    frameId: string;
+} | {
+    status: "error";
+    error: string;
+};
+export type ProgressCallback = (dimensionIndex: number, total: number, phase: "bg-regen" | "layout" | "inserting" | "done" | "error", label: string) => void;
+type ForegroundEl = {
+    kind: "text";
+    elementId: string;
+    slotType?: string;
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+    text: string;
+    fontSize: number;
+    color: string;
+    textAlign: string;
+    fontWeight: string;
+    opacity: number;
+} | {
+    kind: "image";
+    elementId: string;
+    slotType?: string;
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+    dataUrl: string;
+    opacity: number;
+} | {
+    kind: "rect";
+    elementId: string;
+    slotType?: string;
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+    backgroundColor: string;
+    borderRadius: number;
+    opacity: number;
+};
+type SourceFrameInfo = {
+    frame: ExcalidrawFrameLikeElement;
+    background: {
+        type: "solid";
+        color: string;
+        elementId?: string;
+    } | {
+        type: "image";
+        dataUrl: string;
+        elementId?: string;
+    } | {
+        type: "none";
+    };
+    foreground: ForegroundEl[];
+};
+export declare function extractFrameInfo(elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, files: BinaryFiles): SourceFrameInfo;
+export declare function computeCropLoss(sourceAR: number, targetAR: number): number;
+export declare function needsBackgroundRegeneration(srcW: number, srcH: number, tgtW: number, tgtH: number): boolean;
+export declare function nearestGeminiAspectRatio(w: number, h: number): string;
+/**
+ * Selects the optimal resolution for a given target dimension and aspect ratio.
+ * Chooses the resolution level that is closest to (but preferably >= ) the target size.
+ */
+export declare function selectOptimalResolution(targetW: number, targetH: number, aspectRatio: string): "0.5K" | "1K" | "2K" | "4K";
+/**
+ * Returns the x, y, width, height (relative to frame top-left) to place an
+ * image such that:
+ *  - it covers the entire frame (scale up if needed)
+ *  - the centres of the image and frame coincide
+ */
+export declare function fitImageToFrame(imgW: number, imgH: number, frameW: number, frameH: number): {
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+};
+/**
+ * Fit-contain: scale image to fit entirely within the bbox, preserving aspect
+ * ratio, centred. Use for foreground elements (logos, product images) where
+ * cropping or stretching is not acceptable.
+ */
+export declare function containImageInBbox(imgW: number, imgH: number, bboxW: number, bboxH: number): {
+    relX: number;
+    relY: number;
+    width: number;
+    height: number;
+};
+export declare function getProductMinBox(targetW: number, targetH: number): {
+    minWidth: number;
+    minHeight: number;
+};
+export declare function enforceMinProductBox({ x, y, width, height, targetW, targetH, }: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    targetW: number;
+    targetH: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type PreCreatedFrameInfo = {
+    frameId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function preCreateAllFrames(targetDimensions: TargetDimension[], sourceFrame: ExcalidrawFrameLikeElement, app: AppClassProperties): PreCreatedFrameInfo[];
+export declare function runAutoResize(opts: {
+    sourceFrameId: string;
+    targetDimensions: TargetDimension[];
+    app: AppClassProperties;
+    geminiApiKey: string;
+    openRouterApiKey: string;
+    chatModel?: string;
+    agentImageModel?: string;
+    customFontMap?: Record<string, number>;
+    onBeforeAutoResize?: () => Promise<{
+        allowed: boolean;
+        error?: string;
+    }>;
+    onAfterAutoResize?: () => void;
+    onProgress?: ProgressCallback;
+    signal?: AbortSignal;
+    /** Pass the result of preCreateAllFrames() to skip redundant frame creation */
+    preCreatedFrameInfos?: PreCreatedFrameInfo[];
+}): Promise<DimensionResult[]>;
+export {};

package/dist/types/excalidraw/components/auto-resize/autoResizePanelStore.d.ts

@@ -0,0 +1,15 @@
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
+export type AutoResizePanelState = {
+    element: (NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement) | null;
+    isOpen: boolean;
+    isRunning: boolean;
+};
+type Listener = (state: AutoResizePanelState) => void;
+export declare const autoResizePanelStore: {
+    open(element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement): void;
+    close(): void;
+    setRunning(running: boolean): void;
+    getState(): AutoResizePanelState;
+    subscribe(fn: Listener): () => void;
+};
+export {};

package/dist/types/excalidraw/components/auto-resize/autoResizeStore.d.ts

@@ -0,0 +1,16 @@
+export type LoadingFrameInfo = {
+    frameId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type Listener = () => void;
+export declare const autoResizeStore: {
+    setLoadingFrames(frames: LoadingFrameInfo[]): void;
+    markComplete(frameId: string): void;
+    clear(): void;
+    getLoadingFrames(): LoadingFrameInfo[];
+    subscribe(fn: Listener): () => void;
+};
+export {};

package/dist/types/excalidraw/components/hyperlink/Hyperlink.d.ts

@@ -1,6 +1,6 @@
+import "./Hyperlink.scss";
 import type { Scene } from "@orangecatai/element";
 import type { ElementsMap, ExcalidrawEmbeddableElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
-import "./Hyperlink.scss";
 import type { AppState, ExcalidrawProps, UIAppState } from "../../types";
 export declare const Hyperlink: ({ element, scene, setAppState, onLinkOpen, setToast, updateEmbedValidationStatus, }: {
     element: NonDeletedExcalidrawElement;

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

@@ -188,6 +188,7 @@ export declare const alertTriangleIcon: import("react/jsx-runtime").JSX.Element;
 export declare const eyeDropperIcon: import("react/jsx-runtime").JSX.Element;
 export declare const extraToolsIcon: import("react/jsx-runtime").JSX.Element;
 export declare const frameToolIcon: import("react/jsx-runtime").JSX.Element;
+export declare const imageGeneratorToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const mermaidLogoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const RetryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const stackPushIcon: import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/image-generation/pendingGenerations.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pending image generation state — shared across ImageGeneratorPanel and
+ * ImageQuickEditPanel so generation survives panel unmount/remount.
+ *
+ * Flow:
+ * 1. User clicks Generate → startPendingGeneration(id, prompt, settings, controller)
+ *    Stores prompt, model/ratio/resolution, and AbortController. Request continues
+ *    even if user clicks away (no unmount-abort).
+ * 2. Panel subscribes via subscribeGenerationDone(id, cb). If generation already
+ *    finished while unmounted, cb is invoked immediately with finishedError.
+ * 3. On success/error → finishPendingGeneration(id, error) notifies subscribers.
+ * 4. On success only → clearGenerationState(id) removes the entry so reselecting
+ *    the frame/image shows a clean prompt instead of the old one.
+ * 5. Stop button → abortPendingGeneration(id) aborts the controller.
+ */
+export type GenerationDoneCallback = (error: string | null) => void;
+export interface GenerationSettings {
+    model: string;
+    ratio: string;
+    resolution: string;
+}
+export declare function startPendingGeneration(elementId: string, prompt: string, settings: GenerationSettings, controller: AbortController): void;
+export declare function finishPendingGeneration(elementId: string, error: string | null): void;
+export declare function subscribeGenerationDone(elementId: string, fn: GenerationDoneCallback): boolean;
+export declare function unsubscribeGenerationDone(elementId: string, fn: GenerationDoneCallback): void;
+export declare function clearGenerationState(elementId: string): void;
+export declare function abortPendingGeneration(elementId: string): void;
+export declare function getPendingPrompt(elementId: string): string;
+export declare function getPendingSettings(elementId: string): GenerationSettings | null;
+export declare function hasPendingGeneration(elementId: string): boolean;

package/dist/types/excalidraw/components/main-menu/DefaultItems.d.ts

@@ -1,5 +1,5 @@
-import type { Theme } from "@orangecatai/element/types";
 import "./DefaultItems.scss";
+import type { Theme } from "@orangecatai/element/types";
 export declare const LoadScene: {
     (): import("react/jsx-runtime").JSX.Element | null;
     displayName: string;

package/dist/types/excalidraw/components/template-builder/TemplateBuilderPanelHost.d.ts

@@ -0,0 +1,4 @@
+import type { AppClassProperties } from "../../types";
+export declare const TemplateBuilderPanelHost: ({ app, }: {
+    app: AppClassProperties;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/excalidraw/components/template-builder/TemplateBuilderTray.d.ts

@@ -0,0 +1,4 @@
+import type { AppClassProperties } from "../../types";
+export declare const TemplateBuilderTray: ({ app }: {
+    app: AppClassProperties;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/template-builder/slotTypes.d.ts

@@ -0,0 +1,43 @@
+export declare const SLOT_TYPES: readonly [{
+    readonly id: "background";
+    readonly label: "Background";
+    readonly color: "#94a3b8";
+    readonly kind: "rect";
+}, {
+    readonly id: "logo";
+    readonly label: "Logo";
+    readonly color: "#f97316";
+    readonly kind: "image";
+}, {
+    readonly id: "product_image";
+    readonly label: "Product Image";
+    readonly color: "#22c55e";
+    readonly kind: "image";
+}, {
+    readonly id: "headline";
+    readonly label: "Headline";
+    readonly color: "#3b82f6";
+    readonly kind: "text";
+}, {
+    readonly id: "subhead";
+    readonly label: "Subhead";
+    readonly color: "#8b5cf6";
+    readonly kind: "text";
+}, {
+    readonly id: "cta";
+    readonly label: "CTA";
+    readonly color: "#ef4444";
+    readonly kind: "text";
+}, {
+    readonly id: "signoff";
+    readonly label: "Signoff";
+    readonly color: "#64748b";
+    readonly kind: "text";
+}, {
+    readonly id: "auxiliary_image";
+    readonly label: "Aux Image";
+    readonly color: "#14b8a6";
+    readonly kind: "image";
+}];
+export type SlotType = typeof SLOT_TYPES[number];
+export type SlotTypeId = SlotType["id"];

package/dist/types/excalidraw/components/template-builder/templateBuilderStore.d.ts

@@ -0,0 +1,19 @@
+export type TemplateBuilderState = {
+    isOpen: boolean;
+    isBuilding: boolean;
+    templateName: string;
+    campaignTag: string;
+    /** The frame element ID that triggered the template builder (set by FrameToolbar). */
+    sourceFrameId: string | null;
+};
+type Listener = (state: TemplateBuilderState) => void;
+export declare const templateBuilderStore: {
+    open(sourceFrameId?: string): void;
+    close(): void;
+    setBuilding(b: boolean): void;
+    setName(name: string): void;
+    setCampaignTag(tag: string): void;
+    getState(): TemplateBuilderState;
+    subscribe(fn: Listener): () => void;
+};
+export {};

package/dist/types/excalidraw/components/ui/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/types/excalidraw/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "outline" | "secondary" | "destructive" | "ghost" | null | undefined;
+    size?: "icon" | "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/types/excalidraw/components/ui/chat-container.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+export type ChatContainerRootProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+export type ChatContainerContentProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+export type ChatContainerScrollAnchorProps = {
+    className?: string;
+    ref?: React.RefObject<HTMLDivElement>;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function ChatContainerRoot({ children, className, ...props }: ChatContainerRootProps): import("react/jsx-runtime").JSX.Element;
+declare function ChatContainerContent({ children, className, ...props }: ChatContainerContentProps): import("react/jsx-runtime").JSX.Element;
+declare function ChatContainerScrollAnchor({ className, ...props }: ChatContainerScrollAnchorProps): import("react/jsx-runtime").JSX.Element;
+export { ChatContainerRoot, ChatContainerContent, ChatContainerScrollAnchor };

package/dist/types/excalidraw/components/ui/code-block.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+export type CodeBlockProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare function CodeBlock({ children, className, ...props }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export type CodeBlockCodeProps = {
+    code: string;
+    language?: string;
+    theme?: string;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare function CodeBlockCode({ code, language, theme, className, ...props }: CodeBlockCodeProps): import("react/jsx-runtime").JSX.Element;
+export type CodeBlockGroupProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CodeBlockGroup({ children, className, ...props }: CodeBlockGroupProps): import("react/jsx-runtime").JSX.Element;
+export { CodeBlockGroup, CodeBlockCode, CodeBlock };

package/dist/types/excalidraw/components/ui/markdown.d.ts

@@ -0,0 +1,10 @@
+import type { Components } from "react-markdown";
+export type MarkdownProps = {
+    children: string;
+    id?: string;
+    className?: string;
+    components?: Partial<Components>;
+};
+declare function MarkdownComponent({ children, id, className, components, }: MarkdownProps): import("react/jsx-runtime").JSX.Element;
+declare const Markdown: import("react").MemoExoticComponent<typeof MarkdownComponent>;
+export { Markdown };

package/dist/types/excalidraw/components/ui/message.d.ts

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { Markdown } from "./markdown";
+import { Tooltip } from "@/components/ui/tooltip";
+export type MessageProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare const Message: ({ children, className, ...props }: MessageProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageAvatarProps = {
+    src: string;
+    alt: string;
+    fallback?: string;
+    delayMs?: number;
+    className?: string;
+};
+declare const MessageAvatar: ({ src, alt, fallback, delayMs, className, }: MessageAvatarProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageContentProps = {
+    children: React.ReactNode;
+    markdown?: boolean;
+    className?: string;
+} & React.ComponentProps<typeof Markdown> & React.HTMLProps<HTMLDivElement>;
+declare const MessageContent: ({ children, markdown, className, ...props }: MessageContentProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageActionsProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLProps<HTMLDivElement>;
+declare const MessageActions: ({ children, className, ...props }: MessageActionsProps) => import("react/jsx-runtime").JSX.Element;
+export type MessageActionProps = {
+    className?: string;
+    tooltip: React.ReactNode;
+    children: React.ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+} & React.ComponentProps<typeof Tooltip>;
+declare const MessageAction: ({ tooltip, children, className, side, ...props }: MessageActionProps) => import("react/jsx-runtime").JSX.Element;
+export { Message, MessageAvatar, MessageContent, MessageActions, MessageAction, };

package/dist/types/excalidraw/components/ui/prompt-input.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import { Textarea } from "./textarea";
+import { Tooltip } from "./tooltip";
+export type PromptInputProps = {
+    isLoading?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    maxHeight?: number | string;
+    onSubmit?: () => void;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+} & React.ComponentProps<"div">;
+declare function PromptInput({ className, isLoading, maxHeight, value, onValueChange, onSubmit, children, disabled, onClick, ...props }: PromptInputProps): import("react/jsx-runtime").JSX.Element;
+export type PromptInputTextareaProps = {
+    disableAutosize?: boolean;
+} & React.ComponentProps<typeof Textarea>;
+declare function PromptInputTextarea({ className, onKeyDown, disableAutosize, ...props }: PromptInputTextareaProps): import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function PromptInputActions({ children, className, ...props }: PromptInputActionsProps): import("react/jsx-runtime").JSX.Element;
+export type PromptInputActionProps = {
+    className?: string;
+    tooltip: React.ReactNode;
+    children: React.ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+} & React.ComponentProps<typeof Tooltip>;
+declare function PromptInputAction({ tooltip, children, className, side, ...props }: PromptInputActionProps): import("react/jsx-runtime").JSX.Element;
+export { PromptInput, PromptInputTextarea, PromptInputActions, PromptInputAction, };