x-runtime-lib 0.9.29 → 0.9.31

package/dist/index.d.ts

@@ -1,6 +1,977 @@
-export * from './composables/runtime';
-export * from './element';
-export * from './i18n';
-export * from './meta';
-export * from './types';
-export * from './utils';
+import { ComputedRef } from 'vue';
+import { Emitter } from 'mitt';
+import { EventType } from 'mitt';
+import { QuickJSContext } from 'quickjs-emscripten';
+import { QuickJSDeferredPromise } from 'quickjs-emscripten';
+import { QuickJSRuntime } from 'quickjs-emscripten';
+import { Reactive } from 'vue';
+import { Ref } from 'vue';
+import { ShallowRef } from 'vue';
+import { Type } from 'x-essential-lib';
+import { WritableComputedRef } from 'vue';
+
+export declare interface ActivatorContext {
+    props?: Record<string, any>;
+}
+
+export declare function addIndent(code: string, spaces?: number): string;
+
+export declare interface BlockState {
+    type: string;
+    id?: string;
+    x?: number;
+    y?: number;
+    collapsed?: boolean;
+    deletable?: boolean;
+    movable?: boolean;
+    editable?: boolean;
+    enabled?: boolean;
+    disabledReasons?: string[];
+    inline?: boolean;
+    data?: string;
+    extraState?: any;
+    icons?: {
+        [key: string]: any;
+    };
+    fields?: {
+        [key: string]: any;
+    };
+    inputs?: {
+        [key: string]: ConnectionState;
+    };
+    next?: ConnectionState;
+}
+
+export declare type Breakpoint = (typeof breakpoints)[number];
+
+export declare const breakpoints: string[];
+
+export declare function calcBreakpoint(width: number): Breakpoint;
+
+export declare interface Code {
+    blockly: object;
+    script: string;
+    reactivity?: Reactivity;
+}
+
+export declare type CompType = (typeof compTypes)[number];
+
+export declare const compTypes: string[];
+
+declare interface ConnectionState {
+    shadow?: BlockState;
+    block?: BlockState;
+}
+
+export declare function createBreakpointProperty(prototype: ZProperty): ZProperty;
+
+export declare function createMakeNode(type: string, subtype: string): (key: ZElementKey, nodePairs?: NodePair[], props?: {
+    [keys: string]: any;
+}) => NodePair;
+
+export declare function createNode(type: string, subtype: string, key: ZElementKey): Node_2;
+
+export declare interface Data {
+    type: string;
+    version: string;
+    view: View;
+    code: Code;
+}
+
+export declare function dataStringify({ type, version, view, code }: Data): string;
+
+export declare interface Depend {
+    name: string;
+    metaSeq: number;
+    meta: Meta;
+    dataSeq: number;
+    data: Data;
+}
+
+export declare interface Depends {
+    [key: string]: Depend;
+}
+
+export declare type Device = {
+    width: number;
+    height: number;
+};
+
+export declare function duplicateNodePair(src: NodePair): NodePair;
+
+export declare function duplicateNodePairs(srcs: NodePair[]): NodePair[];
+
+export declare const elementKeys: readonly ["globality_v1", "inline_slot_v1", "multiple_ref_v1", "multiple_slot_v1", "ref_v1", "render_switch_v1", "slot_v1", "ui_activator_v1", "ui_badge_v1", "ui_breadcrumbs_v1", "ui_bar_chart_v1", "ui_btn_v1", "ui_btn_toggle_v1", "ui_card_v1", "ui_checkbox_v1", "ui_chip_v1", "ui_chip_group_v1", "ui_color_picker_v1", "ui_combobox_v1", "ui_container_v1", "ui_data_table_client_v1", "ui_data_table_server_v1", "ui_date_picker_v1", "ui_dialog_v1", "ui_expansion_panel_v1", "ui_expansion_panels_v1", "ui_fab_v1", "ui_file_input_v1", "ui_flexbox_v1", "ui_flexbox_entry_v1", "ui_form_v1", "ui_hover_v1", "ui_icon_v1", "ui_item_v1", "ui_item_group_v1", "ui_line_chart_v1", "ui_list_v1", "ui_list_item_v1", "ui_menu_v1", "ui_number_input_v1", "ui_opt_input_v1", "ui_pagination_v1", "ui_positioner_v1", "ui_radio_v1", "ui_radio_group_v1", "ui_range_slider_v1", "ui_rating_v1", "ui_select_v1", "ui_sheet_v1", "ui_slider_v1", "ui_slide_group_v1", "ui_slide_group_item_v1", "ui_speed_dial_v1", "ui_stepper_v1", "ui_stepper_header_v1", "ui_stepper_item_v1", "ui_stepper_window_v1", "ui_stepper_window_item_v1", "ui_switch_v1", "ui_tab_v1", "ui_table_v1", "ui_table_body_v1", "ui_table_body_cell_v1", "ui_table_head_v1", "ui_table_head_cell_v1", "ui_table_row_v1", "ui_tabs_v1", "ui_text_v1", "ui_textarea_v1", "ui_text_field_v1", "ui_timeline_v1", "ui_timeline_item_v1", "ui_tooltip_v1", "ui_window_v1", "ui_window_item_v1", "3d_ambient_light_v1", "3d_box_geometry_v1", "3d_directional_light_v1", "3d_group_v1", "3d_keyboard_controls_v1", "3d_map_controls_v1", "3d_mesh_v1", "3d_mesh_basic_material_v1", "3d_orbit_controls_v1", "3d_orthographic_camera_v1", "3d_perspective_camera_v1", "3d_point_light_v1", "3d_sphere_geometry_v1", "3d_spot_light_v1"];
+
+export declare interface ElementProps {
+    nodeId: string;
+    outer?: boolean;
+    refContext?: RefContext;
+}
+
+export declare type Env = 'dev' | 'prod';
+
+declare type Event_2 = {
+    id: string;
+    name: string;
+    params?: Field[];
+    desc?: string;
+};
+export { Event_2 as Event }
+
+export declare type EventKind = 'elementEvent' | 'elementPropertyChangeEvent' | 'elementSlotEvent' | 'elementSlotPropertyChangeEvent' | 'multipleElementSlotEvent' | 'multipleElementSlotPropertyChangeEvent' | 'refEvent' | 'refPropertyChangeEvent' | 'multipleRefEvent' | 'multipleRefPropertyChangeEvent' | 'customSlotEvent' | 'customSlotPropertyChangeEvent' | 'multipleCustomSlotEvent' | 'multipleCustomSlotPropertyChangeEvent' | 'customEvent' | 'customPropertyChangeEvent' | 'elementAdaptSlotEvent' | 'elementAdaptSlotPropertyChangeEvent' | 'customAdaptSlotEvent' | 'customAdaptSlotPropertyChangeEvent' | 'stateChangeEvent';
+
+export declare type Field = {
+    id: string;
+    name: string;
+    type: Type;
+    desc?: string;
+};
+
+export declare const finalProperties: Properties;
+
+export declare function fromDotString(target: string | string[]): string[];
+
+export declare function genId(len: number): string;
+
+export declare function getAllElements(): {
+    [key: string]: ZElement;
+};
+
+export declare function getBreakpointName(breakpoint: Breakpoint): string;
+
+export declare function getBreakpointProperty<T>(current: Breakpoint, props: {
+    [key: Breakpoint]: T;
+}): T | undefined;
+
+export declare function getElement(key: ZElementKey | string): ZElement | undefined;
+
+export declare function getField(object: any, keys: string | string[]): any;
+
+export declare function getImplementMethodName(kind: MethodKind, nodeId: string, methodKey: string): string;
+
+export declare function getIndexOfBreakpoint(breakpoint: Breakpoint): number;
+
+export declare function getItems(key: ZItemsKey | string): ZItem[] | undefined;
+
+export declare function getNodeLite(nodeLites: NodeLite[], id: string): NodeLite | undefined;
+
+export declare function getPropertyDefault(property: ZProperty): any;
+
+export declare function getPropertyDefaultArray(property: ZProperty): any[] | string[] | number[] | boolean[];
+
+export declare function getRadius(val: unknown): string | undefined;
+
+export declare function getTag(type: string, subtype: string): Tag;
+
+export declare function getTypes(key: ZTypesKey | string): ZType[] | undefined;
+
+export declare function hasComp(key: string): boolean;
+
+export declare function hasInlineSlot(element: ZElement): boolean | undefined;
+
+export declare function hasSlot(key: string): boolean;
+
+declare interface Hooks {
+    onReady: () => Promise<void>;
+    onDestroy: () => void;
+    onPropertyChange: (id: string, newValue: any, oldValue: any, instance?: string) => Promise<void>;
+    onStateChange: (id: string, newValue: any, oldValue: any) => Promise<void>;
+}
+
+export declare function initProperties(node: Node_2, properties: ZProperty[]): void;
+
+export declare function initQuickJS(): Promise<void>;
+
+declare type InitValues = {
+    [key: string]: any;
+};
+
+export declare function injectDark(): Ref<boolean>;
+
+export declare function injectData(): Ref<Data | undefined>;
+
+export declare function injectDepends(): ShallowRef<Depends>;
+
+export declare function injectDevice(): Ref<Device>;
+
+export declare function injectEnv(): Env;
+
+export declare function injectId(): string;
+
+export declare function injectMeta(): Ref<Meta | undefined>;
+
+export declare function injectMode(): Mode;
+
+export declare function injectNode(): Ref<Node_2> | undefined;
+
+export declare function injectNodeLite(): Ref<NodeLite> | undefined;
+
+export declare function injectOrg(): string;
+
+export declare function injectRuntime(): QuickJSRuntime;
+
+export declare function injectSandbox(): Sandbox | undefined;
+
+export declare function injectSlotProps(): Record<string, any> | undefined;
+
+export declare function injectTransients(): Reactive<Transients>;
+
+export declare function injectType(): "page" | "comp";
+
+declare interface Inputs {
+    [key: string]: any;
+}
+
+export declare function isCircularReference(refContext: RefContext, id: string): boolean;
+
+export declare function isExecutableMode(mode: Mode): mode is "runtime" | "preview";
+
+export declare function isHexColor(v: unknown): boolean;
+
+export declare function isInlineSlot(key: string): boolean;
+
+export declare function isPercent(v: unknown): boolean;
+
+export declare function isPixel(v: unknown): boolean;
+
+export declare function isRenderSwitch(key: string): boolean;
+
+export declare function isThemeColor(v: unknown): boolean;
+
+export declare const itemsKeys: readonly ["alignTabsItemsV1", "axisTypeItemsV1", "borderStyleItemsV1", "densityItemsV1", "directionItemsV1", "expansionPanelVariantItemsV1", "fieldVariantItemsV1", "flexCrossAlignItemsV1", "flexDirectionItemsV1", "flexMainAlignItemsV1", "flexWrapItemsV1", "fontWeightItemsV1", "positionItemsV1", "sheetVariantItemsV1", "showTicksItemsV1", "sizeItemsV1", "speedDialOpenWayItemsV1", "textAlignItemsV1", "textDecorationItemsV1", "textEmphasisItemsV1", "textSizeItemsV1", "thumbLabelItemsV1", "timelineAlignItemsV1", "timelineDirectionItemsV1", "timelineSideItemsV1", "timelineTruncateLineItemsV1", "transitionItemsV1"];
+
+export declare function loadLocaleMessageRuntime(locale: string): Promise<object>;
+
+export declare function makeEventId(kind: EventKind, nodeId: string, eventKey: string): string;
+
+export declare function makeEventKeyOfCustomSlot(compId: string, slotId: string, eventId: string): string;
+
+export declare function makeEventKeyOfElementSlot(elementKey: string, slotKey: string, eventKey: string): string;
+
+export declare function makeMethodId(kind: MethodKind, nodeId: string, methodKey: string): string;
+
+export declare function makeMethodKeyOfCustomSlot(compId: string, slotId: string, methodId: string): string;
+
+export declare function makeMethodKeyOfElementSlot(elementKey: string, slotKey: string, methodKey: string): string;
+
+export declare function makeNodePair(node: Node_2, nodePairs?: NodePair[]): NodePair;
+
+export declare function makePropertyId(kind: PropertyKind, nodeId: string, propertyKey: string): string;
+
+export declare function makePropertyKeyOfCustomSlot(compId: string, slotId: string, propertyId: string): string;
+
+export declare function makePropertyKeyOfElementSlot(elementKey: string, slotKey: string, propertyKey: string): string;
+
+export declare function makeSlotId(kind: SlotKind, mainKey: string, slotKey: string): string;
+
+export declare function makeTriggerId(kind: TriggerKind, triggerKey: string): string;
+
+export declare type Meta = {
+    version: string;
+    states?: Field[];
+    arguments?: Field[];
+    properties?: Field[];
+    methods?: Method[];
+    events?: Event_2[];
+    slots?: Slot[];
+};
+
+export declare function metaStringify(meta: Meta): string;
+
+export declare type Method = {
+    id: string;
+    name: string;
+    inputs?: Field[];
+    outputs?: Field[];
+    desc?: string;
+};
+
+export declare type MethodKind = 'elementMethod' | 'elementSlotMethod' | 'multipeElementSlotMethod' | 'refMethod' | 'multipleRefMethod' | 'customSlotMethod' | 'multipleCustomSlotMethod' | 'customMethod' | 'elementAdaptSlotMethod' | 'customAdaptSlotMethod';
+
+export declare type Mode = 'runtime' | 'preview' | 'editor';
+
+declare type Node_2 = {
+    basic: {
+        id: string;
+        key: string;
+        alias?: string;
+    };
+    [key: string]: any;
+};
+export { Node_2 as Node }
+
+export declare type NodeLite = {
+    id: string;
+    key: string;
+    alias?: string;
+    group?: string;
+    render?: boolean;
+    slotId?: string;
+    compId?: string;
+    children?: NodeLite[];
+};
+
+export declare type NodePair = {
+    nodeLite: NodeLite;
+    nodes: {
+        [key: string]: Node_2;
+    };
+};
+
+export declare type PageType = (typeof pageTypes)[number];
+
+export declare const pageTypes: string[];
+
+export declare function parseData(str: string): Data;
+
+export declare function parseMeta(str: string): Meta;
+
+export declare function parsePercent(v: unknown): number;
+
+export declare function parsePixel(v: unknown): number;
+
+export declare const pkgs: ZPkgs;
+
+declare class PromiseManager {
+    private vm;
+    private promises;
+    private currPromiseId;
+    constructor(vm: QuickJSContext);
+    dispose(): void;
+    create(): {
+        promise: QuickJSDeferredPromise;
+        resolve: (value: any) => void;
+        reject: (reason: any) => void;
+    };
+}
+
+declare type Properties = {
+    [key: string]: {
+        [tag: string]: Property[];
+    };
+};
+
+declare type Property = {
+    keys: string;
+    names: string[];
+    raw: ZProperty;
+};
+
+export declare type PropertyKind = 'elementProperty' | 'elementSlotProperty' | 'multipleElementSlotProperty' | 'refProperty' | 'multipleRefProperty' | 'customSlotProperty' | 'multipleCustomSlotProperty' | 'customProperty' | 'elementAdaptSlotProperty' | 'customAdaptSlotProperty';
+
+export declare function provideDark(dark: Ref<boolean>): void;
+
+export declare function provideData(data: Ref<Data | undefined>): void;
+
+export declare function provideDepends(depends: ShallowRef<Depends>): void;
+
+export declare function provideDevice(device: Ref<Device>): void;
+
+export declare function provideEnv(env: Env): void;
+
+export declare function provideId(id: string): void;
+
+export declare function provideMeta(meta: Ref<Meta | undefined>): void;
+
+export declare function provideMode(mode: Mode): void;
+
+export declare function provideNode(node: Ref<Node_2>): void;
+
+export declare function provideNodeLite(nodeLite: Ref<NodeLite>): void;
+
+export declare function provideOrg(org: string): void;
+
+export declare function provideRuntime(runtime: QuickJSRuntime): void;
+
+export declare function provideSandbox(sandbox: Sandbox): void;
+
+export declare function provideSlotProps(slotProps: Record<string, any>): void;
+
+export declare function provideTransients(transients: Reactive<Transients>): void;
+
+export declare function provideType(type: 'page' | 'comp'): void;
+
+export declare interface Reactivity {
+    watchEffect: {
+        ids: string[];
+        triggers: {
+            [key: string]: string[];
+        };
+    };
+    bind: {
+        sets: {
+            [key: string]: string[];
+        };
+        triggers: {
+            [key: string]: string[];
+        };
+    };
+}
+
+export declare interface RefContext {
+    parent?: RefContext;
+    compId: string | undefined;
+}
+
+export declare function regElement(element: ZElement): void;
+
+export declare function regItems(key: ZItemsKey, items: ZItem[]): void;
+
+export declare function regTypes(key: ZTypesKey, types: ZType[]): void;
+
+export declare const reverseBreakpoints: string[];
+
+declare class Sandbox {
+    kind: SandboxKind;
+    nodeId: string;
+    slotId: string;
+    instance: string;
+    parent: Sandbox | undefined;
+    children: {
+        [key: string]: Sandbox;
+    };
+    org: string;
+    env: Env;
+    mode: Mode;
+    type: 'page' | 'comp';
+    eventBus: Emitter<Record<EventType, unknown>>;
+    hooks: Hooks;
+    vm: QuickJSContext | undefined;
+    promiseManager: PromiseManager | undefined;
+    constructor(kind: SandboxKind, nodeId: string, slotId: string, instance: string, parent: Sandbox | undefined, org: string, env: Env, mode: Mode, type: 'page' | 'comp', hooks: Hooks);
+    dispose(): void;
+    debugTrace(...data: any[]): void;
+    private addChild;
+    private removeChild;
+    private meta;
+    private data;
+    private transients;
+    private depends;
+    prepare(meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, transients: Reactive<Transients>, depends: ShallowRef<Depends | undefined>, initValues?: InitValues): void;
+    createVm(runtime: QuickJSRuntime, code: string): Promise<void>;
+    destroyVm(): void;
+    setGlobalVariable(key: string, value: any): void;
+    getGlobalVariable(key: string): any;
+    evalCode(code: string): void;
+    callFunctionSync(funcName: string, ...params: any[]): any;
+    callFunctionAsync(funcName: string, ...params: any[]): Promise<any>;
+    getNode(nodeId: string): Node_2 | undefined;
+    isEqualOfElementSlot(elementKey: string, slotKey: string): boolean;
+    isEqualOfCustomSlot(compId: string, slotId: string): boolean;
+    customProperties: {
+        [key: string]: any;
+    };
+    customSlotProperties: {
+        [key: string]: any;
+    };
+    private resetCustomProperties;
+    private resetCustomSlotProperties;
+    private getMetaOfElementProperty;
+    private isValidOfElementProperty;
+    private isValidOfElementSlotProperty;
+    private isValidOfCustomProperty;
+    private isValidOfCustomSlotProperty;
+    getProperty(id: string, instance?: string): any;
+    private getElementProperty;
+    private getRefProperty;
+    private getMultipleRefProperty;
+    private getCustomSlotProperty;
+    private getMultipleCustomSlotProperty;
+    private getCustomProperty;
+    private getElementAdaptSlotProperty;
+    private getCustomAdaptSlotProperty;
+    setProperty(id: string, newValue: any, instance?: string): Promise<void>;
+    private setElementProperty;
+    private setRefProperty;
+    private setMultipleRefProperty;
+    private setCustomSlotProperty;
+    private setMultipleCustomSlotProperty;
+    private setCustomProperty;
+    private setElementAdaptSlotProperty;
+    private setCustomAdaptSlotProperty;
+    isValidOfElementMethod(elementKey: string, methodKey: string): boolean;
+    isValidOfElementSlotMethod(elementKey: string, slotKey: string, methodKey: string): boolean;
+    isValidOfCustomMethod(methodId: string): boolean;
+    isValidOfCustomSlotMethod(compId: string, slotId: string, methodId: string): boolean;
+    callMethod(id: string, instance: string, inputs: Inputs): Promise<any>;
+    private callElementMethod;
+    private callRefMethod;
+    private callMultipleRefMethod;
+    private callElementAdaptSlotMethod;
+    private callCustomAdaptSlotMethod;
+    isValidOfElementEvent(elementKey: string, eventKey: string): boolean;
+    isValidOfElementSlotEvent(elementKey: string, slotKey: string, eventKey: string): boolean;
+    isValidOfCustomEvent(eventId: string): boolean;
+    isValidOfCustomSlotEvent(compId: string, slotId: string, eventId: string): boolean;
+    triggerEvent(id: string, params: any[], instance?: string): Promise<void>;
+    private triggerElementEvent;
+    private triggerElementPropertyChangeEvent;
+    private triggerElementSlotEvent;
+    private triggerElementSlotPropertyChangeEvent;
+    private triggerMultipleElementSlotEvent;
+    private triggerMultipleElementSlotPropertyChangeEvent;
+    private triggerRefEvent;
+    private triggerRefPropertyChangeEvent;
+    private triggerMultipleRefEvent;
+    private triggerMultipleRefPropertyChangeEvent;
+    private triggerCustomSlotEvent;
+    private triggerCustomSlotPropertyChangeEvent;
+    private triggerMultipleCustomSlotEvent;
+    private triggerMultipleCustomSlotPropertyChangeEvent;
+    private triggerCustomEvent;
+    private triggerCustomPropertyChangeEvent;
+    private triggerElementAdaptSlotEvent;
+    private triggerElementAdaptSlotPropertyChangeEvent;
+    private triggerCustomAdaptSlotEvent;
+    private triggerCustomAdaptSlotPropertyChangeEvent;
+    private triggerStateChangeEvent;
+    private states;
+    private resetStates;
+    isValidOfState(id: string): boolean;
+    getState(id: string): Promise<any>;
+    setState(id: string, newValue: any): Promise<void>;
+}
+
+export declare type SandboxKind = 'root' | 'ref' | 'multipleRef' | 'elementSlot' | 'multipleElementSlot' | 'customSlot' | 'multipleCustomSlot';
+
+export declare function setField(object: any, keys: string | string[], value: any): void;
+
+export declare type Slot = {
+    id: string;
+    name: string;
+    properties?: Field[];
+    methods?: Method[];
+    events?: Event_2[];
+    desc?: string;
+};
+
+export declare type SlotKind = 'elementSlot' | 'multipleElementSlot' | 'customSlot' | 'multipleCustomSlot';
+
+export declare function syncNodeLite(nodeLite: NodeLite, node: Node_2): void;
+
+export declare type Tag = 'pageUi' | 'compUi' | 'page3d' | 'comp3d';
+
+export declare const themeColors: {
+    value: string;
+    title: string;
+}[];
+
+export declare function toDotString(target: string | string[]): string;
+
+export declare function toEventName(kind: EventKind, names: string[]): string;
+
+export declare function toMethodName(kind: MethodKind, names: string[]): string;
+
+export declare function toNodeLite(node: Node_2, children?: NodeLite[]): NodeLite;
+
+export declare function toPropertyName(kind: PropertyKind, names: string[]): string;
+
+export declare function toRenderDefault(children: NodeLite[] | undefined, renderNode: (n: NodeLite, ...params: any[]) => any, ...params: any[]): any[];
+
+export declare function toRenderSlots(children: NodeLite[] | undefined, renderNode: (n: NodeLite, ...params: any[]) => any, ...params: any[]): {
+    [key: string]: any;
+};
+
+export declare interface Transients {
+    [nodeId: string]: {
+        [propertyKey: string]: any;
+    };
+}
+
+export declare type TriggerKind = 'propertyTrigger' | 'stateTrigger';
+
+export declare const typesKeys: readonly ["borderRadiusTypesV1", "borderWidthTypesV1", "colorTypesV1", "leftRightTypesV1", "marginTypesV1", "paddingTypesV1", "sizeTypesV1", "tableColumnAlignTypesV1", "topBottomTypesV1"];
+
+export declare function unwrapEventId(id: string): {
+    kind: EventKind;
+    nodeId: string;
+    eventKey: string;
+};
+
+export declare function unwrapEventKeyOfCustomSlot(key: string): {
+    compId: string;
+    slotId: string;
+    eventId: string;
+};
+
+export declare function unwrapEventKeyOfElementSlot(key: string): {
+    elementKey: string;
+    slotKey: string;
+    eventKey: string;
+};
+
+export declare function unwrapMethodId(id: string): {
+    kind: MethodKind;
+    nodeId: string;
+    methodKey: string;
+};
+
+export declare function unwrapMethodKeyOfCustomSlot(key: string): {
+    compId: string;
+    slotId: string;
+    methodId: string;
+};
+
+export declare function unwrapMethodKeyOfElementSlot(key: string): {
+    elementKey: string;
+    slotKey: string;
+    methodKey: string;
+};
+
+export declare function unwrapPropertyId(id: string): {
+    kind: PropertyKind;
+    nodeId: string;
+    propertyKey: string;
+};
+
+export declare function unwrapPropertyKeyOfCustomSlot(key: string): {
+    compId: string;
+    slotId: string;
+    propertyId: string;
+};
+
+export declare function unwrapPropertyKeyOfElementSlot(key: string): {
+    elementKey: string;
+    slotKey: string;
+    propertyKey: string;
+};
+
+export declare function unwrapSlotId(id: string): {
+    kind: SlotKind;
+    mainKey: string;
+    slotKey: string;
+};
+
+export declare function unwrapTriggerId(id: string): {
+    kind: TriggerKind;
+    triggerKey: string;
+};
+
+export declare function useColor(src: Readonly<Ref<string | undefined>>): {
+    color: ComputedRef<string | undefined>;
+};
+
+export declare function useDepend(compId: Ref<string | undefined>, meta: Ref<Meta | undefined>, data: Ref<Data | undefined>): void;
+
+export declare function useGlobalTransient(sandbox: Sandbox, transients: Reactive<Transients>, propertyKey: string): {
+    property: WritableComputedRef<any, any>;
+};
+
+export declare function useRuntime(): void;
+
+export declare function useSandbox(kind: SandboxKind, nodeId: string, slotId: string, instance: string, parent: Sandbox | undefined, meta: Ref<Meta | undefined>, data: Ref<Data | undefined>, transients: Reactive<Transients>, initValues?: InitValues): {
+    sandbox: Sandbox;
+};
+
+export declare function useTheme(): {
+    theme: ComputedRef<"light" | "dark">;
+};
+
+export declare interface View {
+    nodeLites: NodeLite[];
+    nodes: {
+        globality: Node_2;
+        [key: string]: Node_2;
+    };
+}
+
+declare type WithArray<T extends {
+    default: unknown;
+}> = (T & {
+    array?: false;
+}) | (T & {
+    array: true;
+    defaultArray: T['default'][];
+});
+
+export declare type ZElement = {
+    key: ZElementKey;
+    name: string;
+    comp: any;
+    properties: {
+        [key in Tag]?: ZProperty[];
+    };
+    methods?: ZMethod[];
+    events?: ZEvent[];
+    inlineSlots?: string[];
+    slots?: ZSlot[];
+    internal?: boolean;
+    teleport?: boolean;
+    spawn?: ZSpawnFunc | {
+        func: ZSpawnFunc;
+        desc?: string;
+    }[];
+};
+
+export declare type ZElementKey = (typeof elementKeys)[number];
+
+export declare type ZEvent = {
+    key: string;
+    name: string;
+    params?: {
+        key: string;
+        name: string;
+        type: Type;
+        desc?: string;
+    }[];
+    desc?: string;
+};
+
+export declare type ZGroup = {
+    key: string;
+    name: string;
+    items: ZElementKey[];
+};
+
+export declare type ZItem = {
+    value: string;
+    title: string;
+};
+
+export declare type ZItemsKey = (typeof itemsKeys)[number];
+
+export declare type ZMethod = {
+    key: string;
+    name: string;
+    inputs?: {
+        key: string;
+        name: string;
+        type: Type;
+        desc?: string;
+    }[];
+    outputs?: {
+        key: string;
+        name: string;
+        type: Type;
+        desc?: string;
+    }[];
+    desc?: string;
+};
+
+export declare type ZPkg = {
+    version: string;
+    globalityKey: ZElementKey;
+    refKey: ZElementKey;
+    items: Set<ZItemsKey>;
+    types: Set<ZTypesKey>;
+    groups: {
+        [tag: string]: ZGroup[];
+    };
+};
+
+export declare type ZPkgs = {
+    [key: string]: ZPkg;
+};
+
+export declare type ZProperty = ({
+    array?: false;
+} & ZPropertyBranch) | ({
+    array: true;
+    defaultArray: any[];
+} & ZPropertyBranch) | WithArray<ZPropertyDummy> | WithArray<ZPropertyStrInput> | WithArray<ZPropertyNumInput> | WithArray<ZPropertySwitch> | WithArray<ZPropertySelect> | WithArray<ZPropertyColorPicker> | WithArray<ZPropertyJsonEditor> | WithArray<ZPropertyMultiTypes> | WithArray<ZPropertySelectComp> | WithArray<ZPropertySelectSlot> | WithArray<ZPropertyStrInput> | WithArray<ZPropertySelectAdaptSlot> | WithArray<ZPropertySelectInlineSlot> | WithArray<ZPropertyTransient<Type>>;
+
+declare type ZPropertyBase = {
+    key: string;
+    name: string;
+    readonly?: boolean;
+    static?: boolean;
+    value?: any;
+};
+
+declare type ZPropertyBranch = {
+    key: string;
+    name: string;
+    ui?: undefined;
+    children: ZProperty[];
+};
+
+declare type ZPropertyColorPicker = {
+    ui: 'colorPicker';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertyDummy = {
+    ui: 'dummy';
+    default: any;
+} & ZPropertyBase;
+
+declare type ZPropertyJsonEditor = {
+    ui: 'jsonEditor';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertyMultiTypes = {
+    ui: 'multiTypes';
+    types: ZTypesKey;
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertyNumInput = {
+    ui: 'numInput';
+    precision?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    default: number;
+} & ZPropertyBase;
+
+declare type ZPropertySelect = {
+    ui: 'select';
+    items: ZItemsKey;
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertySelectAdaptSlot = {
+    ui: 'selectAdaptSlot';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertySelectComp = {
+    ui: 'selectComp';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertySelectInlineSlot = {
+    ui: 'selectInlineSlot';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertySelectSlot = {
+    ui: 'selectSlot';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertyStrInput = {
+    ui: 'strInput';
+    default: string;
+} & ZPropertyBase;
+
+declare type ZPropertySwitch = {
+    ui: 'switch';
+    default: boolean;
+} & ZPropertyBase;
+
+declare type ZPropertyTransient<T extends Type> = {
+    ui: 'transient';
+    type: T;
+} & ZPropertyBase & {
+    string: {
+        default: string;
+    };
+    number: {
+        default: number;
+    };
+    boolean: {
+        default: boolean;
+    };
+    object: {
+        default: object;
+    };
+    array: {
+        default: object;
+    };
+    any: {
+        default: any;
+    };
+}[T];
+
+export declare type ZSlot = {
+    key: string;
+    name: string;
+    multiple?: boolean;
+    properties?: ZSlotProperty[];
+    methods?: ZSlotMethod[];
+    events?: ZSlotEvent[];
+    desc?: string;
+};
+
+export declare type ZSlotEvent = {
+    key: string;
+    name: string;
+    params?: {
+        key: string;
+        name: string;
+        type: Type;
+        desc?: string;
+    }[];
+    desc?: string;
+};
+
+export declare type ZSlotMethod = {
+    key: string;
+    name: string;
+    inputs?: {
+        key: string;
+        name: string;
+        type: Type;
+        desc?: string;
+    }[];
+    outputs?: {
+        key: string;
+        name: string;
+        type: Type;
+        desc?: string;
+    }[];
+    desc?: string;
+};
+
+export declare type ZSlotProperty = {
+    key: string;
+    name: string;
+    type: Type;
+    readonly?: boolean;
+    desc?: string;
+};
+
+export declare type ZSpawnFunc = (type: string, subtype: string, ...params: any[]) => ZSpawnResult;
+
+export declare interface ZSpawnResult {
+    nodePairs: NodePair[];
+    blockStates?: BlockState[];
+}
+
+export declare type ZType = ZTypeWord | ZTypePixel | ZTypePercent | ZTypeHexColor | ZTypeThemeColor;
+
+declare type ZTypeBase = {
+    value: string;
+    title: string;
+    validator: (v: unknown) => boolean;
+};
+
+declare type ZTypeHexColor = {
+    trait: 'hexColor';
+    default: string;
+} & ZTypeBase;
+
+declare type ZTypePercent = {
+    trait: 'percent';
+    precision?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    default: string;
+} & ZTypeBase;
+
+declare type ZTypePixel = {
+    trait: 'pixel';
+    precision?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    default: string;
+} & ZTypeBase;
+
+export declare type ZTypesKey = (typeof typesKeys)[number];
+
+declare type ZTypeThemeColor = {
+    trait: 'themeColor';
+    default: string;
+} & ZTypeBase;
+
+declare type ZTypeWord = {
+    trait: 'word';
+    default: string;
+} & ZTypeBase;
+
+export { }