@versa-stack/v-craft 0.0.1

package/dist/types/components/composable/useCraftNodeWrapper.d.ts

@@ -0,0 +1,390 @@
+import { Ref } from 'vue';
+import { CraftNode } from '../../lib/craftNode';
+export declare const useCraftNodeWrapper: <T extends object>(craftNode: Ref<CraftNode>) => {
+    editor: import('pinia').Store<"editor", import('../../store/editor').EditorState, {
+        hasNodes: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => boolean;
+        selectedNode: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => CraftNode | null;
+        selectedRef: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => HTMLElement | null;
+        getRef: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => (uuid: string) => HTMLElement;
+        allNodes: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => CraftNode[];
+        getDraggedNode: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => {
+            slots: Record<string, CraftNode[]>;
+            componentName: string;
+            parentUuid?: string | null | undefined;
+            props: any;
+            rules?: {
+                canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+            } | undefined;
+            uuid: string;
+            visible?: boolean | undefined;
+            events?: Record<string, string> | undefined;
+        } | null;
+        nodeTree: (state: {
+            nodeMap: Map<string, {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            }> & Omit<Map<string, CraftNode>, keyof Map<any, any>>;
+            rootNodes: string[];
+            selectedUuid: string | null;
+            draggedNode: {
+                slots: Record<string, CraftNode[]>;
+                componentName: string;
+                parentUuid?: string | null | undefined;
+                props: any;
+                rules?: {
+                    canMoveIn?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canMoveOut?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                    canDrag?: (<T_1 extends object>(craftNode: CraftNode) => boolean) | undefined;
+                    canMoveInto?: (<T_1 extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: import('../..').CraftNodeResolver<T_1>) => boolean) | undefined;
+                } | undefined;
+                uuid: string;
+                visible?: boolean | undefined;
+                events?: Record<string, string> | undefined;
+            } | null;
+            enabled: boolean;
+            nodeRefsRecord: Record<string, HTMLElement>;
+            resolver: {
+                resolverMap: import('../..').CraftNodeResolverMap<import('@formkit/core').FormKitSchemaFormKit>;
+                setResolverMap: (resolverMap: Record<string, import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>>) => void;
+                resolve: (name: string) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getDefaultProps: (craftNode: CraftNode) => Record<string, any>;
+                resolveNode: (craftNode: CraftNode) => import('../..').CraftNodeComponentMap<import('@formkit/core').FormKitSchemaFormKit>;
+                getSchema: (craftNode: CraftNode) => Record<string, any>;
+                getEventsSchema: (craftNode: CraftNode) => Record<string, any>;
+                getRules: (craftNode: CraftNode) => import('../../lib/craftNode').CraftNodeRules;
+            } | null;
+            eventsContext: Record<string, any>;
+            nodeDataMap: Record<string, import('../../lib/craftNode').CraftNodeDatasource | null>;
+            draggingDisabled: boolean;
+        } & import('pinia').PiniaCustomStateProperties<import('../../store/editor').EditorState>) => CraftNode[];
+    }, {
+        clear(): void;
+        enable(): void;
+        disable(): void;
+        disableDragging(): void;
+        enableDragging(): void;
+        setResolver(resolver: import('../..').CraftNodeResolver<import('@formkit/core').FormKitSchemaFormKit>): void;
+        setNodeRef(craftNode: CraftNode, ref: HTMLElement): void;
+        toggleNodeVisibility(craftNode: CraftNode): void;
+        setNodeData(uuid: string, data: import('../../lib/craftNode').CraftNodeDatasource | null): void;
+        updateNodeProps(nodeUuid: string, newProps: Record<string, any>): void;
+        updateNodeEvents(nodeUuid: string, newEvents: Record<string, string>): void;
+        setNodes(nodes: CraftNode[]): void;
+        addNodeRecursively(node: CraftNode, parentUuid?: string | null): void;
+        selectNode(craftNode: CraftNode | null): void;
+        dragNode(craftNode: CraftNode | null): void;
+        removeNode(craftNode: CraftNode): void;
+        emancipateNode(craftNode: CraftNode): CraftNode;
+        addNodeAndChildrenToMap(node: CraftNode): void;
+        appendNodeTo(node: CraftNode, targetNode: CraftNode, slotName?: string): void;
+        prependNodeTo(node: CraftNode, targetNode: CraftNode, slotName?: string): void;
+        insertNodeBefore(node: CraftNode, targetNode: CraftNode, slotName?: string): void;
+        insertNodeAfter(node: CraftNode, targetNode: CraftNode, slotName?: string): void;
+        setEventsContext(context: Record<string, any>): void;
+    }> | null;
+    craftNode: Ref<CraftNode, CraftNode>;
+    enabled: import('vue').ComputedRef<any>;
+    visible: import('vue').ComputedRef<boolean>;
+};

package/dist/types/components/composable/useDragCraftNode.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { CraftNode } from '../../lib/craftNode';
+import { default as CraftNodeResolver } from '../../lib/CraftNodeResolver';
+declare const _default: <T extends object>(craftNode: Ref<CraftNode>, nodeRef: Ref<any>, resolver: CraftNodeResolver<T>) => {
+    handleDragStart: (e: MouseEvent) => void;
+    handleDragOver: (e: MouseEvent) => void;
+    handleDrop: (e: MouseEvent) => void;
+    handleDragEnd: () => void;
+};
+export default _default;

package/dist/types/components/composable/useModal.d.ts

@@ -0,0 +1,5 @@
+export declare const useModal: () => {
+    isModalOpen: import('vue').Ref<boolean, boolean>;
+    openModal: () => void;
+    closeModal: () => void;
+};

package/dist/types/components/composable/useResolveCraftNode.d.ts

@@ -0,0 +1,8 @@
+import { ComputedRef, Ref } from 'vue';
+import { CraftNode } from '../../lib/craftNode';
+import { default as CraftNodeResolver, CraftNodeComponentMap } from '../../lib/CraftNodeResolver';
+export declare const useResolveCraftNode: <T extends object>(craftNode: Ref<CraftNode>) => {
+    resolvedNode: ComputedRef<CraftNodeComponentMap<T>>;
+    resolver: ComputedRef<CraftNodeResolver<T>>;
+    defaultProps: ComputedRef<Record<string, any>>;
+};

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

@@ -0,0 +1,28 @@
+import { CraftNode } from '../lib/craftNode';
+import { default as CraftCanvas } from './CraftCanvas.vue';
+import { default as CraftComponentSimpleText } from './CraftComponentSimpleText.vue';
+import { default as CraftEditor } from './CraftEditor.vue';
+import { default as CraftEditorBlueprint } from './CraftEditorBlueprint.vue';
+import { default as CraftEditorBlueprintsList } from './CraftEditorBlueprintsList.vue';
+import { default as CraftEditorPanelBlueprints } from './CraftEditorPanelBlueprints.vue';
+import { default as CraftEditorPanelForm } from './CraftEditorPanelForm.vue';
+import { default as CraftEditorPanelLayers } from './CraftEditorPanelLayers.vue';
+import { default as CraftEditorPanelLayout } from './CraftEditorPanelLayout.vue';
+import { default as CraftEditorPanelNodeEventsSettings } from './CraftEditorPanelNodeEventsSettings.vue';
+import { default as CraftEditorPanelNodeLayer } from './CraftEditorPanelNodeLayer.vue';
+import { default as CraftEditorPanelNodeSettings } from './CraftEditorPanelNodeSettings.vue';
+import { default as CraftEditorPanelSettings } from './CraftEditorPanelSettings.vue';
+import { default as CraftFrame } from './CraftFrame.vue';
+import { default as CraftNodeEditor } from './CraftNodeEditor.vue';
+import { default as CraftNodeViewer } from './CraftNodeViewer.vue';
+import { default as CraftIframe } from './CraftIframe.vue';
+import { default as CraftStaticRenderer } from './CraftStaticRenderer.vue';
+import * as Utils from "./utils";
+export { CraftCanvas, CraftComponentSimpleText, CraftEditor, CraftEditorBlueprint, CraftEditorBlueprintsList, CraftEditorPanelBlueprints, CraftEditorPanelForm, CraftEditorPanelLayers, CraftEditorPanelLayout, CraftEditorPanelNodeEventsSettings, CraftEditorPanelNodeLayer, CraftEditorPanelNodeSettings, CraftEditorPanelSettings, CraftFrame, CraftIframe, CraftNodeEditor, CraftNodeViewer, CraftStaticRenderer, Utils, };
+export type CraftDataListItem<T extends object> = {
+    dataItem: any;
+    dataIndex: number;
+    childNode: CraftNode;
+    childIndex: number;
+    key: string;
+};

package/dist/types/components/utils.d.ts

@@ -0,0 +1,12 @@
+import { CraftNode } from '../lib/craftNode';
+import { default as CraftNodeResolver } from '../lib/CraftNodeResolver';
+import { BlueprintGroup } from '../lib/model';
+export declare const blueprintsWithDefaults: <T extends object>(group: BlueprintGroup, resolver: CraftNodeResolver<T>) => {
+    props: any;
+    slots: Record<string, CraftNode[]> & Record<string, import('../lib/model').Blueprint[]>;
+    componentName: string;
+    rules?: import('../lib/craftNode').CraftNodeRules | undefined;
+    visible?: boolean | undefined;
+    events?: Record<string, string> | undefined;
+    label?: string;
+}[];

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+import { App } from 'vue';
+export * from './blueprints/default';
+export * from './components';
+export * from './components/composable';
+export * from './lib/craftNode';
+export * from './lib/CraftNodeResolver';
+export * from './lib/mapData';
+export * from './lib/model';
+export * from './lib/renderCraftNodes';
+export * from './resolvers/default';
+export { useEditor } from './store/editor';
+export type { EditorState, EditorStoreInstanceType } from './store/editor';
+export { useIndicator } from './store/indicator';
+export type { IndicatorState, IndicatorStoreType } from './store/indicator';
+export declare const VCraft: {
+    install: (app: App) => void;
+};

package/dist/types/lib/CraftNodeResolver.d.ts

@@ -0,0 +1,23 @@
+import { FormKitSchemaFormKit } from '@formkit/core';
+import { CraftNode, CraftNodeRules } from './craftNode';
+export type CraftNodeComponentMap<T extends object> = {
+    componentName: string;
+    propsSchema?: T;
+    eventsSchema?: T;
+    defaultProps?: Record<string, any>;
+    rules?: CraftNodeRules;
+    slots?: string[];
+};
+export type CraftNodeResolverMap<T extends object> = Record<string, CraftNodeComponentMap<T>>;
+export declare class CraftNodeResolver<T extends object = FormKitSchemaFormKit[]> {
+    resolverMap: CraftNodeResolverMap<T>;
+    constructor(resolverMap?: Record<string, CraftNodeComponentMap<T>>);
+    setResolverMap(resolverMap: Record<string, CraftNodeComponentMap<T>>): void;
+    resolve(name: string): CraftNodeComponentMap<T>;
+    getDefaultProps(craftNode: CraftNode): Record<string, any>;
+    resolveNode(craftNode: CraftNode): CraftNodeComponentMap<T>;
+    getSchema(craftNode: CraftNode): Record<string, any>;
+    getEventsSchema(craftNode: CraftNode): Record<string, any>;
+    getRules(craftNode: CraftNode): CraftNodeRules;
+}
+export default CraftNodeResolver;

package/dist/types/lib/craftNode.d.ts

@@ -0,0 +1,32 @@
+import { default as CraftNodeResolver } from './CraftNodeResolver';
+export type CraftNodeRules = {
+    canMoveIn?: <T extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: CraftNodeResolver<T>) => boolean;
+    canMoveOut?: <T extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: CraftNodeResolver<T>) => boolean;
+    canDrag?: <T extends object>(craftNode: CraftNode) => boolean;
+    canMoveInto?: <T extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: CraftNodeResolver<T>) => boolean;
+};
+export type CraftNode = {
+    slots: Record<string, CraftNode[]>;
+    componentName: string;
+    parentUuid?: string | null;
+    props: any;
+    rules?: CraftNodeRules;
+    uuid: string;
+    visible?: boolean;
+    events?: Record<string, string>;
+};
+export type CraftNodeDatasource = {
+    item?: Record<string, any>;
+    list?: Record<string, any>[];
+    type: "single" | "list";
+    slotName?: string;
+};
+export declare const isVisible: (craftNode: CraftNode) => boolean;
+export declare const craftNodeInCanvas: <T extends object>(craftNode: CraftNode) => boolean;
+export declare const craftNodeIsDraggable: <T extends object>(craftNode: CraftNode) => boolean;
+export declare const craftNodeIsAncestorOf: <T extends object>(craftNode: CraftNode, descendant: CraftNode) => boolean;
+export declare const resolveNodeName: <T extends object>(craftNode: CraftNode) => any;
+export declare const craftNodeCanBeChildOf: <T extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: CraftNodeResolver<T>) => boolean | undefined;
+export declare const craftNodeIsCanvas: <T extends object>(craftNode: CraftNode) => boolean;
+export declare const craftNodeCanBeSiblingOf: <T extends object>(craftNode: CraftNode, targetNode: CraftNode, resolver: CraftNodeResolver<T>) => boolean | undefined;
+export declare const buildCraftNodeTree: <T extends object>(craftNode: CraftNode) => CraftNode;

package/dist/types/lib/dragCraftNode/dragOver.d.ts

@@ -0,0 +1,3 @@
+import { DragCraftNodeContext } from './drop';
+declare const _default: <T extends object>(e: MouseEvent, el: HTMLElement, context: DragCraftNodeContext<T>) => void;
+export default _default;

package/dist/types/lib/dragCraftNode/drop.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { EditorStoreInstanceType } from '../../store/editor';
+import { IndicatorStoreType } from '../../store/indicator';
+import { CraftNode } from '../craftNode';
+import { default as CraftNodeResolver } from '../CraftNodeResolver';
+export type DragCraftNodeContext<T extends object> = {
+    editor: EditorStoreInstanceType;
+    indicator: IndicatorStoreType;
+    craftNode: Ref<CraftNode>;
+    resolver: CraftNodeResolver<T>;
+};
+declare const _default: <T extends object>(e: MouseEvent, el: HTMLElement, context: DragCraftNodeContext<T>) => CraftNode;
+export default _default;

package/dist/types/lib/dragCraftNode/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    handleDragOver: <T extends object>(e: MouseEvent, el: HTMLElement, context: import('./drop').DragCraftNodeContext<T>) => void;
+    handleDrop: <T extends object>(e: MouseEvent, el: HTMLElement, context: import('./drop').DragCraftNodeContext<T>) => import('../craftNode').CraftNode;
+};
+export default _default;

package/dist/types/lib/dragCraftNode/mouse.d.ts

@@ -0,0 +1,3 @@
+export declare const mouseOnLeftHalf: (e: MouseEvent, el: HTMLElement) => boolean;
+export declare const mouseOnTopHalf: (e: MouseEvent, el: HTMLElement) => boolean;
+export declare const mouseOnEdge: (e: MouseEvent, el: HTMLElement) => boolean;

package/dist/types/lib/jsonPathTransform.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (data: Record<string, any>, path: Record<string, any> | string | string[]) => Record<string, any> | undefined;
+export default _default;

package/dist/types/lib/mapData.d.ts

@@ -0,0 +1,3 @@
+import { CraftDataWrapperPropMap, CraftDataPatch } from './model';
+import { CraftNodeDatasource } from './craftNode';
+export declare const mapData: <M extends CraftDataWrapperPropMap = CraftDataWrapperPropMap<any, any>, D extends CraftNodeDatasource = CraftNodeDatasource, P extends CraftDataPatch = CraftDataPatch<any, any>>(data: any, mapConfig: M, childRef: any) => D;

package/dist/types/lib/model.d.ts

@@ -0,0 +1,43 @@
+import { CraftNodeResolverMap } from './CraftNodeResolver';
+import { CraftNode } from './craftNode';
+export type CraftBlueprintData = {
+    label: string;
+    component: string;
+    props: Record<string, any>;
+};
+export type BlueprintsLibrary = {
+    metadata?: BlueprintsMetadata;
+    groups: BlueprintGroup[];
+};
+export type BlueprintGroup = {
+    label: string;
+    metadata: BlueprintsMetadata;
+    blueprints: Blueprints;
+};
+export type BlueprintsMetadata = {
+    name: string;
+    description?: string;
+    help?: string;
+};
+export type Blueprints = Record<string, Blueprint>;
+export type Blueprint = Omit<CraftNode, "parentUuid" | "uuid"> & {
+    label?: string;
+    slots: Record<string, Blueprint[]>;
+};
+export type CraftEditorConfig<T extends object> = {
+    blueprintsLibrary: BlueprintsLibrary;
+    resolverMap: CraftNodeResolverMap<T>;
+};
+export type CraftDataPatch<V = any, D = any> = {
+    defaultValue?: D;
+    fromPath: string;
+    patchSource: "mapPathResult" | "value" | "child";
+    toPath: string;
+    type: "single" | "list";
+    value?: V;
+};
+export type CraftDataWrapperPropMap<V = any, D = any> = {
+    fromPath: string;
+    patches: CraftDataPatch<V, D>[];
+    type: "single" | "list";
+};