chesai-ui 0.9.2 → 0.12.0

package/dist/components/toolbar/index.d.ts

@@ -1,47 +1,45 @@
-import { VariantProps } from 'class-variance-authority';
 import { default as React } from 'react';
-import { iconButtonVariants } from '../icon-button';
 import * as ToolbarPrimitive from "@radix-ui/react-toolbar";
-type ToolbarSize = "sm" | "md" | "lg";
-type ToolbarShape = "full" | "minimal" | "sharp";
-declare const toolbarVariants: (props?: ({
-    orientation?: "horizontal" | "vertical" | null | undefined;
-    variant?: "primary" | "secondary" | "ghost" | null | undefined;
-    shape?: "full" | "minimal" | "sharp" | null | undefined;
-    shadow?: "sm" | "md" | "lg" | "none" | null | undefined;
-    padding?: "sm" | "md" | "lg" | "none" | null | undefined;
-    gap?: "sm" | "md" | "lg" | "none" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
-declare const toggleItemVariants: (props?: ({
-    variant?: "default" | "primary" | "outline" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-    shape?: "full" | "minimal" | "sharp" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
 interface ToolbarItemTooltipProps {
     children: React.ReactElement;
     content: string;
     shortcut?: string;
 }
-export interface ToolbarProps extends React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Root>, VariantProps<typeof toolbarVariants> {
-    size: "sm" | "md" | "lg";
+declare const ToolbarItemTooltip: ({ children, content, shortcut, }: ToolbarItemTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export interface ToolbarProps extends React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Root> {
+    orientation?: "horizontal" | "vertical";
+    variant?: "primary" | "secondary" | "ghost";
+    shape?: "full" | "minimal" | "sharp";
+    shadow?: "none" | "sm" | "md" | "lg";
+    padding?: "none" | "sm" | "md" | "lg";
+    gap?: "none" | "sm" | "md" | "lg";
+    size?: "sm" | "md" | "lg";
 }
-interface ToolbarButtonProps extends React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Button>, VariantProps<typeof iconButtonVariants> {
-    size?: ToolbarSize;
-    shape?: ToolbarShape;
+declare const ToolbarRoot: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<never>>;
+declare const ToolbarSeparator: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Separator> & React.RefAttributes<React.ElementRef<typeof ToolbarPrimitive.Separator>>>;
+export interface ToolbarButtonProps extends React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Button> {
+    variant?: "primary" | "secondary" | "tertiary" | "outline" | "destructive" | "ghost" | "link";
+    size?: "sm" | "md" | "lg";
+    shape?: "full" | "minimal" | "sharp";
     tooltip?: string;
     shortcut?: string;
+    isLoading?: boolean;
 }
-interface ToolbarToggleItemProps extends React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.ToggleItem>, VariantProps<typeof toggleItemVariants> {
-    size?: ToolbarSize;
-    shape?: ToolbarShape;
+declare const ToolbarButton: React.ForwardRefExoticComponent<ToolbarButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const ToolbarToggleGroup: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.ToggleGroup> & React.RefAttributes<React.ElementRef<typeof ToolbarPrimitive.ToggleGroup>>>;
+export interface ToolbarToggleItemProps extends React.ComponentPropsWithoutRef<typeof ToolbarPrimitive.ToggleItem> {
+    variant?: "default" | "outline" | "primary";
+    size?: "sm" | "md" | "lg";
+    shape?: "full" | "minimal" | "sharp";
     tooltip?: string;
     shortcut?: string;
 }
-export declare const Toolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>> & {
-    Button: React.ForwardRefExoticComponent<ToolbarButtonProps & React.RefAttributes<HTMLButtonElement>>;
-    Separator: React.ForwardRefExoticComponent<Omit<ToolbarPrimitive.ToolbarSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-    ToggleGroup: React.ForwardRefExoticComponent<(Omit<ToolbarPrimitive.ToolbarToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToolbarPrimitive.ToolbarToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & React.RefAttributes<HTMLDivElement>>;
-    ToggleItem: React.ForwardRefExoticComponent<ToolbarToggleItemProps & React.RefAttributes<HTMLButtonElement>>;
-    ItemTooltip: ({ children, content, shortcut, }: ToolbarItemTooltipProps) => import("react/jsx-runtime").JSX.Element;
+declare const ToolbarToggleItem: React.ForwardRefExoticComponent<ToolbarToggleItemProps & React.RefAttributes<never>>;
+export declare const Toolbar: typeof ToolbarRoot & {
+    Button: typeof ToolbarButton;
+    Separator: typeof ToolbarSeparator;
+    ToggleGroup: typeof ToolbarToggleGroup;
+    ToggleItem: typeof ToolbarToggleItem;
+    ItemTooltip: typeof ToolbarItemTooltip;
 };
 export {};

package/dist/components/tooltip/index.d.ts

@@ -1,4 +1,4 @@
-import { useFloating } from '@floating-ui/react';
+import { useFloating, Placement } from '@floating-ui/react';
 import { default as React } from 'react';
 export interface TooltipProps extends React.HTMLAttributes<HTMLDivElement> {
     variant?: "primary" | "secondary";
@@ -20,8 +20,9 @@ interface TooltipContextType {
     arrowRef: React.RefObject<HTMLDivElement>;
 }
 export declare const useTooltip: () => TooltipContextType;
-export declare const TooltipProvider: ({ children, }: {
+export declare const TooltipProvider: ({ children, placement, }: {
     children: React.ReactNode;
+    placement?: Placement;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLElement> & {
     asChild?: boolean;

package/dist/components/tree-view/index.d.ts

@@ -0,0 +1,52 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const treeItemVariants: (props?: ({
+    variant?: "primary" | "secondary" | "ghost" | null | undefined;
+    shape?: "full" | "minimal" | "sharp" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface FlattenedNode<T> {
+    id: string;
+    item: T;
+    parentId: string | null;
+    depth: number;
+    isExpanded: boolean;
+    hasChildren: boolean;
+}
+export interface TreeViewProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect">, VariantProps<typeof treeItemVariants> {
+    data: T[];
+    getId: (item: T) => string;
+    getChildren: (item: T) => T[] | undefined | null;
+    canHaveChildren?: (item: T) => boolean;
+    renderItem: (item: T, options: {
+        isExpanded: boolean;
+        isSelected: boolean;
+        depth: number;
+        isDragging: boolean;
+    }) => React.ReactNode;
+    selectedId?: string | null;
+    onSelect?: (id: string, item: T) => void;
+    multiSelect?: boolean;
+    selectedIds?: string[];
+    onSelectChange?: (ids: string[], items: T[]) => void;
+    expandedIds?: string[];
+    onExpandedChange?: (expandedIds: string[]) => void;
+    indentSize?: number;
+    enableDragAndDrop?: boolean;
+    onMoveNode?: (args: {
+        activeId: string;
+        activeIds: string[];
+        parentId: string | null;
+        index: number;
+    }) => void;
+}
+export declare function TreeView<T>({ data, getId, getChildren, canHaveChildren, renderItem, selectedId, onSelect, multiSelect, selectedIds, onSelectChange, expandedIds: controlledExpandedIds, onExpandedChange, variant, shape, size, indentSize, enableDragAndDrop, onMoveNode, className, ...props }: TreeViewProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function useTreeHistory<T>(initialData: T[]): {
+    data: T[];
+    updateData: (newData: T[] | ((prev: T[]) => T[])) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export {};

package/dist/components/view-transition/index.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export * from './use-view-transition';
+export * from './useGlobalViewTransitions';
+export interface TransitionLinkProps extends React.HTMLAttributes<HTMLElement> {
+    /**
+     * The imperative navigation function to execute (e.g., router.push('/about'))
+     */
+    onNavigate: () => void | Promise<void>;
+    /**
+     * Set to true to merge props onto a child element instead of rendering a <div>
+     */
+    asChild?: boolean;
+}
+export declare const TransitionLink: React.ForwardRefExoticComponent<TransitionLinkProps & React.RefAttributes<HTMLElement>>;

package/dist/components/view-transition/use-view-transition.d.ts

@@ -0,0 +1 @@
+export declare function useViewTransition(): <T>(callback: () => T | Promise<T>) => Promise<void>;

package/dist/components/view-transition/useGlobalViewTransitions.d.ts

@@ -0,0 +1 @@
+export declare function useGlobalViewTransitions(): void;

package/dist/components/virtual-list/index.d.ts

@@ -6,7 +6,7 @@ export interface VirtualListProps<T> {
     /** The render function for each item */
     renderItem: (item: T, index: number) => React.ReactNode;
     /** Scroll direction of the virtual list. @default "vertical" */
-    direction?: "vertical" | "horizontal";
+    direction?: "vertical" | "horizontal" | "vertical-reverse" | "horizontal-reverse";
     /**
      * The component used as the outer scrollable container viewport.
      * Useful for passing ElasticScrollArea or customizing tags.
@@ -35,7 +35,6 @@ export interface VirtualListProps<T> {
     contentProps?: React.HTMLAttributes<HTMLDivElement> & Record<string, any>;
     /**
      * Access to the raw TanStack Virtual options for advanced logic
-     * (e.g., initialOffset, scrollMargin, etc.)
      */
     virtualOptions?: Partial<VirtualizerOptions<any, any>>;
     /** Ref to access the virtualizer instance from parent (for scroll controls) */

package/dist/components/website-studio/BuilderContext.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { ComponentRegistry, DesignSystemSchema } from './types';
+interface BuilderContextValue {
+    components: ComponentRegistry;
+    cms?: any;
+    actions?: Record<string, Function>;
+    customApi?: any;
+    globalHeadCode?: string;
+    globalBodyCode?: string;
+    designSystem?: DesignSystemSchema;
+}
+export declare const useBuilderContext: () => BuilderContextValue;
+export declare const BuilderContextProvider: ({ children, components, cms, actions, customApi, globalHeadCode, globalBodyCode, designSystem, }: BuilderContextValue & {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/website-studio/ScriptAndStyleInjector.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export interface ScriptAndStyleInjectorProps {
+    /** The raw HTML string containing elements like scripts, styles, or meta tags */
+    html?: string;
+    /** Where to append the extracted tags inside the document */
+    target: "head" | "body";
+}
+/**
+ * Safely parses and injects custom head or body scripts/styles inside the client environment.
+ * Automatically scopes injections to the document it mounts in (crucial for iframe isolation).
+ */
+export declare const ScriptAndStyleInjector: React.FC<ScriptAndStyleInjectorProps>;

package/dist/components/website-studio/ThemeInjector.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { DesignSystemSchema } from './types';
+interface ThemeInjectorProps {
+    designSystem: DesignSystemSchema;
+    children: React.ReactNode;
+}
+/**
+ * Injects the agnostic design system tokens as CSS Variables into a wrapper div.
+ * This guarantees the styling cascades down to all child components.
+ */
+export declare const ThemeInjector: React.FC<ThemeInjectorProps>;
+export {};

package/dist/components/website-studio/builder/ComponentPickerDialog.d.ts

@@ -0,0 +1 @@
+export declare const ComponentPickerDialog: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/website-studio/builder/ComponentsTab.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ComponentTreeNode } from './types';
+interface ComponentsTabProps {
+    assetSearch: string;
+    setAssetSearch: (val: string) => void;
+    componentTreeData: ComponentTreeNode[];
+    expandedAssetIds: string[];
+    setExpandedAssetIds: React.Dispatch<React.SetStateAction<string[]>>;
+}
+export declare const ComponentsTab: React.FC<ComponentsTabProps>;
+export {};

package/dist/components/website-studio/builder/InspectorPanel.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface InspectorPanelProps {
+    selectedNodeIds: string[];
+}
+export declare const InspectorPanel: React.FC<InspectorPanelProps>;
+export {};

package/dist/components/website-studio/builder/LayersTab.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { ComponentRegistry, StudioNode } from '../types';
+interface LayersTabProps {
+    layerSearch: string;
+    setLayerSearch: (val: string) => void;
+    displayedLayers: StudioNode[];
+    expandedLayerIds: string[];
+    setExpandedLayerIds: React.Dispatch<React.SetStateAction<string[]>>;
+    components: ComponentRegistry;
+}
+export declare const LayersTab: React.FC<LayersTabProps>;
+export {};

package/dist/components/website-studio/builder/PageDialogs.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+interface PageDialogsProps {
+    isAddPageOpen: boolean;
+    setIsAddPageOpen: (open: boolean) => void;
+    newPageSlug: string;
+    setNewPageSlug: (val: string) => void;
+    newPageTitle: string;
+    setNewPageTitle: (val: string) => void;
+    handleCreatePage: () => void;
+    editingPageId: string | null;
+    setEditingPageId: (id: string | null) => void;
+    editPageSlug: string;
+    setEditPageSlug: (val: string) => void;
+    editPageTitle: string;
+    setEditPageTitle: (val: string) => void;
+    handleEditPage: () => void;
+}
+export declare const PageDialogs: React.FC<PageDialogsProps>;
+export {};

package/dist/components/website-studio/builder/PagesTab.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { PageNode, PageAction } from './types';
+interface PagesTabProps {
+    pageSearch: string;
+    setPageSearch: (val: string) => void;
+    displayedPagesTree: PageNode[];
+    expandedPageIds: string[];
+    setExpandedPageIds: React.Dispatch<React.SetStateAction<string[]>>;
+    setIsAddPageOpen: (open: boolean) => void;
+    openEditPage: (id: string) => void;
+    customPageActions?: PageAction[];
+}
+export declare const PagesTab: React.FC<PagesTabProps>;
+export {};

package/dist/components/website-studio/builder/PreviewOverlay.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export interface PreviewOverlayProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+export declare const PreviewOverlay: React.FC<PreviewOverlayProps>;

package/dist/components/website-studio/builder/helpers.d.ts

@@ -0,0 +1,3 @@
+import { StudioNode } from '../types';
+export declare const getNodeIcon: (type: string) => import("react/jsx-runtime").JSX.Element;
+export declare const filterTree: (nodes: StudioNode[], query: string) => StudioNode[];

package/dist/components/website-studio/builder/types.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { PageSchema } from '../types';
+export interface PageAction {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    destructive?: boolean;
+    run: (pageId: string, page: PageSchema) => void;
+}
+export interface PageNode {
+    id: string;
+    slug: string;
+    name: string;
+    title: string;
+    children: PageNode[];
+    pageId: string;
+}
+export interface ComponentTreeNode {
+    id: string;
+    name: string;
+    isCategory: boolean;
+    children?: ComponentTreeNode[];
+}

package/dist/components/website-studio/builder.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { ComponentRegistry, WebsiteSchema, DesignSystemSchema } from './types';
+import { PageAction } from './builder/types';
+export interface BuilderProps {
+    components: ComponentRegistry;
+    initialState: WebsiteSchema;
+    cms?: any;
+    actions?: Record<string, Function>;
+    customApi?: any;
+    globalHeadCode?: string;
+    globalBodyCode?: string;
+    designSystem?: DesignSystemSchema;
+    topBarLeft?: React.ReactNode;
+    topBarCenter?: React.ReactNode;
+    topBarRight?: React.ReactNode;
+    customPageActions?: PageAction[];
+    onExit?: () => void;
+}
+export declare const Builder: React.FC<BuilderProps>;

package/dist/components/website-studio/canvas/ArtboardIframe.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export declare const ArtboardIframe: ({ children, title, defaultHeight, }: {
+    children: React.ReactNode;
+    title: string;
+    defaultHeight: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/website-studio/canvas/ArtboardNode.d.ts

@@ -0,0 +1,2 @@
+import { NodeProps } from '@xyflow/react';
+export declare const ArtboardNode: ({ data, selected }: NodeProps<any>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/website-studio/canvas/CanvasOverlay.d.ts

@@ -0,0 +1,7 @@
+import { InteractionState, DropTarget } from './artboard-types';
+export declare const CanvasOverlay: ({ iframeWindow, interaction, dropTarget, inlineEditElement, }: {
+    iframeWindow: Window;
+    interaction: InteractionState;
+    dropTarget: DropTarget | null;
+    inlineEditElement: HTMLElement | null;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/website-studio/canvas/IframeWrappers.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export declare const NavigationInterceptor: ({ children, onNavigate, }: {
+    children: React.ReactNode;
+    onNavigate: (linkTo: string) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const IframeContentObserver: ({ children, onHeightChange, }: {
+    children: React.ReactNode;
+    onHeightChange: (h: number) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/website-studio/canvas/StudioCanvas.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+export interface StudioAIConfig {
+    enabled: boolean;
+    suggestions?: string[];
+    models?: string[];
+    defaultModel?: string;
+    onModelChange?: (model: string) => void;
+    onPromptSubmit?: (prompt: string, context: {
+        nodes: any[];
+        files: File[];
+        model?: string;
+    }) => void;
+    onPanelCollapseToggle?: (isOpen: boolean) => void;
+    logsContent?: React.ReactNode;
+    customActions?: React.ReactNode;
+}
+interface CanvasInnerProps {
+    aiConfig?: StudioAIConfig;
+}
+export declare const StudioCanvas: ({ aiConfig }: CanvasInnerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/website-studio/canvas/artboard-types.d.ts

@@ -0,0 +1,53 @@
+export type InteractionState = {
+    type: 'idle';
+} | {
+    type: 'marquee_prep';
+    startCoords: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'marquee';
+    startCoords: {
+        x: number;
+        y: number;
+    };
+    currentCoords: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'drag_prep';
+    startCoords: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'drag';
+    startCoords: {
+        x: number;
+        y: number;
+    };
+    currentCoords: {
+        x: number;
+        y: number;
+    };
+};
+export type DropTarget = {
+    parentId: string | null;
+    index?: number;
+    type: 'line' | 'box';
+    rect: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+};
+export type ArtboardData = {
+    label: string;
+    width: number;
+    height: number;
+    isIsolationMode?: boolean;
+    componentId?: string;
+};

package/dist/components/website-studio/canvas/artboard-utils.d.ts

@@ -0,0 +1,17 @@
+import { ComponentControl, StudioNode } from '../types';
+export declare const isRectEqual: (a: DOMRect | null | undefined, b: DOMRect | null | undefined) => boolean;
+export declare const findNodeById: (nodes: StudioNode[], id: string) => StudioNode | null;
+export declare const getParentAndIndex: (nodes: StudioNode[], targetId: string, parentId?: string | null) => {
+    parentId: string | null;
+    index: number;
+} | null;
+export declare function generateSingleAxisVariations(controls: Record<string, ComponentControl>): {
+    baselineProps: Record<string, any>;
+    groups: {
+        propName: string;
+        variations: {
+            props: Record<string, any>;
+            value: any;
+        }[];
+    }[];
+};

package/dist/components/website-studio/defaultActions.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A standard, safe library of built-in actions that work universally
+ * within the Renderer engine runtime context.
+ */
+export declare const defaultActions: Record<string, Function>;

package/dist/components/website-studio/index.d.ts

@@ -0,0 +1,11 @@
+export { defaultActions } from './defaultActions';
+export { ScriptAndStyleInjector } from './ScriptAndStyleInjector';
+export { useStudioStore } from './store';
+export * from './types';
+export declare const WebsiteStudio: {
+    Renderer: import('react').FC<import('./renderer').RendererProps>;
+    Builder: import('react').FC<import('./builder').BuilderProps>;
+    PreviewOverlay: import('react').FC<import('./builder/PreviewOverlay').PreviewOverlayProps>;
+    ScriptAndStyleInjector: import('react').FC<import('./ScriptAndStyleInjector').ScriptAndStyleInjectorProps>;
+    defaultActions: Record<string, Function>;
+};

package/dist/components/website-studio/renderer.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { ComponentRegistry, DesignSystemSchema, PageSchema, StudioNode } from './types';
+export interface ResponsiveValue {
+    mobile?: string | number;
+    tablet?: string | number;
+    desktop?: string | number;
+    default?: string | number;
+}
+export declare function isResponsiveValue(value: any): value is ResponsiveValue;
+interface ProcessedStyles {
+    cleanProps: Record<string, any>;
+    styleTagContent: string | null;
+}
+export declare function processResponsiveStyles(nodeId: string, props: Record<string, any>, responsiveCssProps?: string[]): ProcessedStyles;
+export declare const ThemeInjector: React.FC<{
+    designSystem: DesignSystemSchema;
+    children: React.ReactNode;
+}>;
+export interface RendererProps {
+    components: ComponentRegistry;
+    data: PageSchema | StudioNode[];
+    designSystem?: DesignSystemSchema;
+    cms?: any;
+    actions?: Record<string, Function>;
+    customApi?: any;
+    globalHeadCode?: string;
+    globalBodyCode?: string;
+    pageHeadCode?: string;
+}
+export declare const Renderer: React.FC<RendererProps>;
+export {};

package/dist/components/website-studio/store.d.ts

@@ -0,0 +1,47 @@
+import { StudioNode, WebsiteSchema } from './types';
+interface StudioState {
+    website: WebsiteSchema | null;
+    activePageId: string | null;
+    past: WebsiteSchema[];
+    future: WebsiteSchema[];
+    undo: () => void;
+    redo: () => void;
+    selectedNodeIds: string[];
+    hoveredNodeId: string | null;
+    componentPicker: {
+        isOpen: boolean;
+        action: 'before' | 'after' | 'inside' | 'replace' | null;
+        targetId: string | null;
+    };
+    openComponentPicker: (action: 'before' | 'after' | 'inside' | 'replace', targetId: string) => void;
+    closeComponentPicker: () => void;
+    viewContext: {
+        type: 'PAGE' | 'COMPONENT';
+        id: string | null;
+    };
+    clipboard: StudioNode[];
+    copyNodes: (nodeIds: string[]) => void;
+    pasteNodes: (targetId: string | null, position?: 'inside' | 'after') => void;
+    duplicateNodes: (nodeIds: string[]) => void;
+    initStudio: (schema: WebsiteSchema) => void;
+    setActivePage: (pageId: string) => void;
+    setViewContext: (type: 'PAGE' | 'COMPONENT', id: string | null) => void;
+    setSelectedNodes: (ids: string[]) => void;
+    toggleNodeSelection: (id: string, multi: boolean) => void;
+    setHoveredNode: (id: string | null) => void;
+    addNode: (node: StudioNode, parentId?: string | null, index?: number) => void;
+    removeNodes: (nodeIds: string[]) => void;
+    moveNode: (nodeId: string, targetParentId: string | null, index?: number) => void;
+    moveNodes: (nodeIds: string[], targetParentId: string | null, index?: number) => void;
+    updateNodeProps: (nodeId: string, props: Record<string, any>) => void;
+    updateNodeId: (oldId: string, newId: string) => void;
+    updateDesignSystemTokens: (tokens: Record<string, string | number>) => void;
+    insertNodeRelative: (node: StudioNode, targetId: string, position: 'before' | 'after' | 'inside') => void;
+    replaceNode: (targetId: string, newNode: StudioNode) => void;
+    addPage: (slug: string, title: string) => void;
+    updatePage: (id: string, slug: string, title: string) => void;
+    duplicatePage: (id: string) => void;
+    removePage: (id: string) => void;
+}
+export declare const useStudioStore: import('zustand').UseBoundStore<import('zustand').StoreApi<StudioState>>;
+export {};