@orangecatai/element 0.0.2 → 0.0.4

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,74 @@
+/**
+ * reviewerAgent.ts
+ *
+ * Brand Governance Agent — stateless reviewer that runs after the main agent
+ * generates a complete ad image (visuals + all copy baked in) and calls
+ * finalize_ad. It receives a focused context (the rendered screenshot, frame
+ * dimensions, brand guidelines, original user brief) and returns a precise
+ * critique covering creative quality AND brand-governance compliance:
+ * copy correctness, brand tone, logo usage, claim accuracy, legal mandatories,
+ * offer disclaimers, regulatory sensitivity, prohibited language, competitive
+ * claims, and data/privacy concerns.
+ *
+ * The reviewer is a separate LLM call from the main agent loop so it brings an
+ * independent eye to the generated ad. Because the ad is a single image, every
+ * fix is applied by regenerating the image with a revised prompt — there is no
+ * HTML/CSS layer to patch.
+ *
+ * @deprecated note (2026-06-17): this reviewer previously audited an HTML text
+ * layer composited over a text-free image and emitted CSS-only fixes. That
+ * flow is gone — see the image-first agent loop in agentLoop.ts.
+ */
+import type { BrandContext } from "../../types";
+export type ReviewIssue = {
+    /** Which design element or governance dimension is affected */
+    element: "headline" | "subheadline" | "cta" | "image" | "layout" | "brand" | "brand_tone" | "logo" | "claim" | "legal" | "disclaimer" | "regulatory" | "prohibited_language" | "competitive_claim" | "privacy";
+    /** 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;
+    /** Host proxy URL for the reviewer's OpenRouter call. Key stays server-side. */
+    chatUrl: string;
+    /** OpenRouter model tag. Must be vision-capable. Defaults to minimax/minimax-m3 */
+    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, autoResizeUrl, chatModel, agentImageModel, }: {
+    element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement;
+    app: AppClassProperties;
+    onClose: () => void;
+    onBeforeAutoResize?: () => Promise<{
+        allowed: boolean;
+        error?: string;
+    }>;
+    onAfterAutoResize?: () => void;
+    onRunningChange?: (running: boolean) => void;
+    autoResizeUrl: 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,185 @@
+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;
+/**
+ * Resolution dimensions available for each aspect ratio in Gemini 3.1 Flash
+ * Image (Nano Banana 2). Maps aspect ratio → resolution level → [width, height].
+ * Exported so the Auto Resize panel can build its dimension presets from the
+ * exact model-supported sizes instead of duplicating the numbers.
+ */
+export declare const GEMINI_RESOLUTION_TABLE: Record<string, Record<string, [number, number]>>;
+/**
+ * Resolution levels offered by the Auto Resize panel.
+ * Nano Banana (gemini-2.5-flash-image) and Nano Banana 2 (gemini-3.1-flash-image-preview)
+ * both support 0.5K–4K. 0.5K is the fastest/cheapest tier.
+ */
+export declare const AUTO_RESIZE_RESOLUTIONS: readonly ["0.5K", "1K", "2K", "4K"];
+export type AutoResizeResolution = typeof AUTO_RESIZE_RESOLUTIONS[number];
+/**
+ * Aspect ratios the Nano Banana 2 / Gemini 3.1 Flash Image model supports,
+ * ordered for display (common first, then the ultrawide / extreme-narrow ones).
+ * Each carries a human label for the panel.
+ */
+export declare const AUTO_RESIZE_ASPECT_RATIOS: {
+    ratio: string;
+    desc: string;
+}[];
+/**
+ * Concrete pixel dimensions for a given aspect ratio + resolution, straight from
+ * the Nano Banana 2 resolution table. Falls back to 1:1 / 1K if unknown.
+ */
+export declare function geminiDimsFor(ratio: string, resolution: string): {
+    width: number;
+    height: number;
+};
+/**
+ * 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;
+    autoResizeUrl: 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[];
+    /**
+     * Brand assets handed to the image model so the recomposed ad keeps the brand
+     * logo, typeface, and (for font-aware models) the real font file. Sourced from
+     * `app.state.brandContext` by the panel.
+     */
+    brandImages?: {
+        logo?: string;
+        fontPreview?: string;
+        fontUrl?: string;
+        name?: string;
+    };
+}): 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

@@ -33,6 +33,7 @@ export declare const FreedrawIcon: import("react/jsx-runtime").JSX.Element;
 export declare const TextIcon: import("react/jsx-runtime").JSX.Element;
 export declare const TextSizeIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ImageIcon: import("react/jsx-runtime").JSX.Element;
+export declare const VideoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const EraserIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ZoomInIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ZoomOutIcon: import("react/jsx-runtime").JSX.Element;
@@ -188,6 +189,8 @@ 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 videoGeneratorToolIcon: 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/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;
@@ -12,6 +12,10 @@ export declare const SaveAsImage: {
     (): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
+export declare const UploadVideo: {
+    (): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
 export declare const CommandPalette: {
     (opts?: {
         className?: 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, };