@improba/page-builder 0.1.3 → 0.2.1

package/dist/types/components/editor/NodeContextMenu.vue.d.ts

@@ -0,0 +1,66 @@
+export type NodeContextMenuAction = 'duplicate' | 'delete' | 'move-up' | 'move-down';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    x: {
+        type: NumberConstructor;
+        default: number;
+    };
+    y: {
+        type: NumberConstructor;
+        default: number;
+    };
+    canDelete: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canMoveUp: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canMoveDown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    action: (action: NodeContextMenuAction) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    x: {
+        type: NumberConstructor;
+        default: number;
+    };
+    y: {
+        type: NumberConstructor;
+        default: number;
+    };
+    canDelete: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canMoveUp: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canMoveDown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onAction?: ((action: NodeContextMenuAction) => any) | undefined;
+}>, {
+    open: boolean;
+    y: number;
+    x: number;
+    canDelete: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/PageEditor.vue.d.ts

@@ -0,0 +1,20 @@
+import { type PropType } from 'vue';
+import type { IPageData, INode, IPageSavePayload } from '@/types/node';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    pageData: {
+        type: PropType<IPageData>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    save: (payload: IPageSavePayload) => any;
+    change: (tree: INode) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    pageData: {
+        type: PropType<IPageData>;
+        required: true;
+    };
+}>> & Readonly<{
+    onSave?: ((payload: IPageSavePayload) => any) | undefined;
+    onChange?: ((tree: INode) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/PbIcon.vue.d.ts

@@ -0,0 +1,25 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    icon: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    icon: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    icon: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/RightDrawer.vue.d.ts

@@ -0,0 +1,43 @@
+import { type PropType } from 'vue';
+import type { INode } from '@/types/node';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedNodeId: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    content: {
+        type: PropType<INode>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    delete: (nodeId: number) => any;
+    toggle: () => any;
+    "update-props": (nodeId: number, props: Record<string, unknown>) => any;
+    duplicate: (nodeId: number) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedNodeId: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    content: {
+        type: PropType<INode>;
+        required: true;
+    };
+}>> & Readonly<{
+    onDelete?: ((nodeId: number) => any) | undefined;
+    onToggle?: (() => any) | undefined;
+    "onUpdate-props"?: ((nodeId: number, props: Record<string, unknown>) => any) | undefined;
+    onDuplicate?: ((nodeId: number) => any) | undefined;
+}>, {
+    selectedNodeId: number | null;
+    open: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/TreePanel.vue.d.ts

@@ -0,0 +1,28 @@
+import { type PropType } from 'vue';
+import type { INode } from '@/types/node';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    content: {
+        type: PropType<INode>;
+        required: true;
+    };
+    selectedNodeId: {
+        type: PropType<number | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (nodeId: number) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    content: {
+        type: PropType<INode>;
+        required: true;
+    };
+    selectedNodeId: {
+        type: PropType<number | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    onSelect?: ((nodeId: number) => any) | undefined;
+}>, {
+    selectedNodeId: number | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/MediaPicker.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    upload: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onUpload?: (() => any) | undefined;
+}>, {
+    modelValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/PropBooleanEditor.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    modelValue: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/PropColorEditor.vue.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    modelValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/PropNumberEditor.vue.d.ts

@@ -0,0 +1,36 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: number | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number | undefined) => any) | undefined;
+}>, {
+    min: number;
+    max: number;
+    modelValue: string | number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/PropSelectEditor.vue.d.ts

@@ -0,0 +1,31 @@
+import type { IPropDefinition } from '@/types/component';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    options: {
+        type: () => IPropDefinition["options"];
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    options: {
+        type: () => IPropDefinition["options"];
+        default: () => never[];
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | boolean | undefined) => any) | undefined;
+}>, {
+    modelValue: string | number | boolean;
+    options: {
+        label: string;
+        value: string | number | boolean;
+    }[] | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/PropTextEditor.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    placeholder: string;
+    modelValue: string | number | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/RichTextEditor.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    placeholder: string;
+    modelValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/editor/prop-editors/index.d.ts

@@ -0,0 +1,29 @@
+import type { Component } from 'vue';
+import type { PropEditorType } from '@/types/component';
+export declare const DEFAULT_PROP_EDITOR: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    placeholder: string;
+    modelValue: string | number | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PROP_EDITORS: Partial<Record<PropEditorType, Component>>;

package/dist/types/components/reader/NodeRenderer.vue.d.ts

@@ -0,0 +1,33 @@
+import { type PropType } from 'vue';
+import type { INode } from '@/types/node';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<INode>;
+        required: true;
+    };
+    variables: {
+        type: PropType<Record<string, string>>;
+        default: () => {};
+    };
+    markNodes: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<INode>;
+        required: true;
+    };
+    variables: {
+        type: PropType<Record<string, string>>;
+        default: () => {};
+    };
+    markNodes: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    variables: Record<string, string>;
+    markNodes: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/reader/PageReader.vue.d.ts

@@ -0,0 +1,14 @@
+import { type PropType } from 'vue';
+import type { IPageData } from '@/types/node';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    pageData: {
+        type: PropType<IPageData>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    pageData: {
+        type: PropType<IPageData>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/shared/ErrorBoundary.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    fallbackMessage?: string;
+    showDetailsInDev?: boolean;
+    diagnosticContext?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    fallbackMessage: string;
+    showDetailsInDev: boolean;
+    diagnosticContext: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/composables/use-drag-drop.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from 'vue';
+export interface DragState {
+    isDragging: boolean;
+    sourceNodeId: number | null;
+    sourceComponentName: string | null;
+    isNewComponent: boolean;
+    dropTargetId: number | null;
+    dropIndex: number;
+    dropSlot: string;
+}
+export interface DragDropApi {
+    dragState: Ref<DragState>;
+    startDragExisting: (nodeId: number) => void;
+    startDragNew: (componentName: string) => void;
+    updateDropTarget: (targetId: number, index: number, slot?: string) => void;
+    endDrag: () => DragState;
+    cancelDrag: () => void;
+}
+/**
+ * Composable for drag-and-drop interactions in the editor.
+ * Handles both dragging existing nodes and new components from the palette.
+ */
+export declare function useDragDrop(): DragDropApi;

package/dist/types/composables/use-editor.d.ts

@@ -0,0 +1,40 @@
+import type { ViewportPreset } from '@/types/editor';
+interface UseEditorOptions {
+    initialSnapshot?: string;
+    initialLabel?: string;
+}
+/**
+ * Composable managing the editor UI state (selection, drawers, history, viewport).
+ * Drag-and-drop state is handled separately by useDragDrop.
+ */
+export declare function useEditor(options?: UseEditorOptions): {
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    selectNode: (id: number | null) => void;
+    hoverNode: (id: number | null) => void;
+    toggleLeftDrawer: () => void;
+    toggleRightDrawer: () => void;
+    setViewport: (preset: ViewportPreset) => void;
+    setHistoryBaseline: (snapshot: string, label?: string) => void;
+    pushHistory: (label: string, snapshot: string) => void;
+    undo: () => string | undefined;
+    redo: () => string | undefined;
+    selectedNodeId: import("vue").Ref<number | null, number | null>;
+    hoveredNodeId: import("vue").Ref<number | null, number | null>;
+    leftDrawerOpen: import("vue").Ref<boolean, boolean>;
+    rightDrawerOpen: import("vue").Ref<boolean, boolean>;
+    history: import("vue").Ref<{
+        timestamp: number;
+        label: string;
+        snapshot: string;
+    }[], {
+        timestamp: number;
+        label: string;
+        snapshot: string;
+    }[]>;
+    historyIndex: import("vue").Ref<number, number>;
+    isDirty: import("vue").Ref<boolean, boolean>;
+    canvasScale: import("vue").Ref<number, number>;
+    viewport: import("vue").Ref<ViewportPreset, ViewportPreset>;
+};
+export {};

package/dist/types/composables/use-node-tree.d.ts

@@ -0,0 +1,23 @@
+import type { Ref } from 'vue';
+import type { INode } from '@/types/node';
+export interface UseNodeTreeOptions {
+    content: Ref<INode>;
+    nextId: () => number;
+    onUpdate: (newContent: INode) => void;
+    onSnapshot?: (label: string) => void;
+}
+/**
+ * Composable for manipulating the node tree (add, remove, move, update props).
+ * All mutations clone before modifying to preserve immutability for history.
+ */
+export declare function useNodeTree({ content, nextId, onUpdate, onSnapshot }: UseNodeTreeOptions): {
+    addNode: (parentId: number, componentName: string, index: number, slot?: string, defaultProps?: Record<string, unknown>) => number | null;
+    deleteNode: (nodeId: number) => void;
+    moveNodeTo: (nodeId: number, newParentId: number, index: number, slot?: string) => void;
+    updateNodeProps: (nodeId: number, props: Record<string, unknown>) => void;
+    duplicateNode: (nodeId: number) => void;
+    canMoveNodeUp: (nodeId: number) => boolean;
+    canMoveNodeDown: (nodeId: number) => boolean;
+    moveNodeUp: (nodeId: number) => void;
+    moveNodeDown: (nodeId: number) => void;
+};

package/dist/types/composables/use-page-builder.d.ts

@@ -0,0 +1,28 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { IPageData, INode } from '@/types/node';
+import type { PageBuilderMode } from '@/types/editor';
+export interface UsePageBuilderOptions {
+    initialData: IPageData;
+    mode?: PageBuilderMode;
+}
+export interface UsePageBuilderReturn {
+    mode: Ref<PageBuilderMode>;
+    pageData: ComputedRef<IPageData>;
+    content: Ref<INode>;
+    layout: Ref<INode>;
+    maxId: Ref<number>;
+    variables: Ref<Record<string, string>>;
+    isDirty: Ref<boolean>;
+    setMode: (newMode: PageBuilderMode) => void;
+    updateContent: (newContent: INode) => void;
+    updateLayout: (newLayout: INode) => void;
+    nextId: () => number;
+    getSnapshot: () => string;
+    restoreSnapshot: (snapshot: string) => void;
+    reset: () => void;
+}
+/**
+ * Main composable for managing page builder state.
+ * Used internally by the PageBuilder component.
+ */
+export declare function usePageBuilder(options: UsePageBuilderOptions): UsePageBuilderReturn;

package/dist/types/core/drop-slot.d.ts

@@ -0,0 +1,12 @@
+import type { INode } from '@/types/node';
+import type { ISlotDefinition } from '@/types/component';
+/**
+ * Slots of the parent component that accept the given child component name.
+ * Used to validate drop targets (canvas and tree panel).
+ */
+export declare function getAllowedDropSlots(parentNode: INode, componentName: string): ISlotDefinition[];
+/**
+ * Resolve a valid slot name for dropping the given component into the parent,
+ * or null if the parent does not accept this component in any slot.
+ */
+export declare function normalizeDropSlot(parentNode: INode, preferredSlot: string | null | undefined, componentName: string): string | null;

package/dist/types/core/errors.d.ts

@@ -0,0 +1,14 @@
+export type PageBuilderErrorCode = 'INVALID_PAGE_DATA' | 'INVALID_NODE' | 'INVALID_SNAPSHOT' | 'MISSING_COMPONENT' | 'DUPLICATE_COMPONENT' | 'RENDER_FAILURE' | 'UNKNOWN';
+export interface PageBuilderErrorOptions {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+}
+export declare class PageBuilderError extends Error {
+    readonly code: PageBuilderErrorCode;
+    readonly details: Record<string, unknown>;
+    constructor(code: PageBuilderErrorCode, message: string, options?: PageBuilderErrorOptions);
+}
+export declare function isPageBuilderError(error: unknown): error is PageBuilderError;
+export declare function createPageBuilderError(code: PageBuilderErrorCode, message: string, options?: PageBuilderErrorOptions): PageBuilderError;
+export declare function toErrorMessage(error: unknown): string;
+export declare function reportDevDiagnostic(context: string, error: unknown, details?: Record<string, unknown>): void;