@toolmain/components 1.2.2 → 1.2.4

package/dist/index.d.ts

@@ -1,11 +1,27 @@
-import type { Component } from 'vue';
+import { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
+import { CSS2DObject } from 'three/addons';
 import type * as CSS_2 from 'csstype';
 import { DefineComponent } from 'vue';
+import { Dexie } from 'dexie';
+import { DialogProps } from 'element-plus';
+import { EntityTable } from 'dexie';
+import { EventBus as EventBus_2 } from '@toolmain/shared';
+import { GLTF } from 'three/addons';
 import type { MaybeRef } from 'vue';
+import { OrbitControls } from 'three/addons';
+import { PointerLockControls } from 'three/addons';
 import { PublicProps } from 'vue';
-import type { VNode } from 'vue';
+import { Reactive } from 'vue';
+import { RoundedBoxGeometry } from 'three/addons';
+import { ShallowRef } from 'vue';
+import { default as Stats_2 } from 'three/addons/libs/stats.module.js';
+import { StoreDefinition } from 'pinia';
+import * as THREE from 'three';
+import { TransformControlsMode } from 'three/addons';
+import { VNode } from 'vue';
+import { VNodeProps } from 'vue';
 
 declare const __VLS_component: DefineComponent<__VLS_Props, {
 update: () => void;
@@ -29,6 +45,20 @@ onMaskClick?: (() => any) | undefined;
 "onUpdate:modelValue"?: ((data: ScaleConfig) => any) | undefined;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
+declare const __VLS_component_3: DefineComponent<__VLS_Props_2, {
+world: World;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+loaded: (args_0: World) => any;
+targetClick: (args_0: TargetData) => any;
+}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
+onLoaded?: ((args_0: World) => any) | undefined;
+onTargetClick?: ((args_0: TargetData) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_4: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_5: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
 declare type __VLS_Props = {
     /**
      * 选择top时,如果元素滚动到[底部]消失或即将消失，会回到原位置
@@ -40,6 +70,36 @@ declare type __VLS_Props = {
     offset?: number;
 };
 
+declare type __VLS_Props_2 = {
+    /**
+     * if true, will add a panel for debugging. press `m` to toggle the panel
+     */
+    debug?: boolean;
+    /**
+     * if you want to use draco decoder, must specify `dracoDecoderPath`
+     *
+     * 1. you can set the path with cdn url: `https://www.gstatic.com/draco/versioned/decoders/1.5.7/`
+     * 2. or copy the draco decoder files to your `/public/droc/gltf` directory, and set the value to `/droc/gltf`
+     */
+    dracoDecoderPath?: string;
+    /**
+     * config for rendering models
+     */
+    config: ThreePanelConf;
+};
+
+declare type __VLS_Props_3 = {
+    text: string;
+};
+
+declare type __VLS_Props_4 = {
+    modelValue?: boolean;
+    /**
+     * @description 如果为true，则在icon不可视时摧毁元素而不是隐藏透明度
+     */
+    destroyIcon?: boolean;
+};
+
 declare type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 };
@@ -50,6 +110,22 @@ declare type __VLS_Slots_2 = {} & {
     default?: (props: typeof __VLS_7) => any;
 };
 
+declare type __VLS_Slots_3 = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+
+declare type __VLS_Slots_4 = {} & {
+    header?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_15) => any;
+} & {
+    footer?: (props: typeof __VLS_18) => any;
+};
+
+declare type __VLS_Slots_5 = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+
 declare type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
@@ -62,6 +138,29 @@ declare type __VLS_WithSlots_2<T, S> = T & {
     };
 };
 
+declare type __VLS_WithSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithSlots_4<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithSlots_5<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+/**
+ * anger to rad
+ */
+export declare function a2r(angle: number): number;
+
 export declare const Affix: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 
 export declare type AnimateDir = "left" | "top" | "bottom" | "right" | "self" | "center" | {
@@ -71,6 +170,154 @@ export declare type AnimateDir = "left" | "top" | "bottom" | "right" | "self" |
 
 declare type ArrMutKeys = "splice" | "push" | "pop" | "shift" | "unshift";
 
+export declare class Bot {
+    box: THREE.Box3;
+    size: THREE.Vector3;
+    animateDuration: number;
+    model?: GLTF;
+    animations: THREE.AnimationClip[];
+    mixer: THREE.AnimationMixer | undefined;
+    skeleton: THREE.SkeletonHelper | undefined;
+    /**
+     * preset actions lists,in clude weight,name,and Action instance
+     */
+    baseActions: BotAction[];
+    direction: THREE.Vector3;
+    move: {
+        forward: boolean;
+        backward: boolean;
+        left: boolean;
+        right: boolean;
+        speed: number;
+        jumpHeight: number;
+        canJump: boolean;
+        jumping: boolean;
+        status: string;
+        onFloor: boolean;
+    };
+    initPosition: THREE.Vector3;
+    readonly loader: Loader;
+    readonly core: Core;
+    readonly collider?: ReturnType<typeof useCollider>;
+    private currentAction?;
+    private uv;
+    private actionMap;
+    constructor(opts: BotOptions);
+    /**
+     * load bot
+     */
+    load(gltfPath: string, conf?: LoadOptions): Promise<GLTF | null>;
+    /**
+     * teleport bot to a new position
+     */
+    teleport(x: number, y: number, z: number): void;
+    update(delta: number): void;
+    once<K extends keyof BotEv>(event: K, callback: BotEv[K]): Bot;
+    on<K extends keyof BotEv>(event: K, callback: BotEv[K]): Bot;
+    emit<K extends keyof BotEv>(event: K, ...args: Parameters<BotEv[K]>): Bot;
+    run(): void;
+    walk(): void;
+    idle(): void;
+    dispose(): void;
+    private init;
+    private setWeight;
+    private _action;
+}
+
+export declare interface BotAction {
+    name: string;
+    action: THREE.AnimationAction;
+}
+
+export declare type BotActionMap = {
+    [key in BotActionName]: string;
+};
+
+export declare enum BotActionName {
+    IDLE = "idle",
+    RUN = "run",
+    WALK = "walk",
+    JUMP = "jump"
+}
+
+export declare interface BotEv {
+    BotPos: (e: THREE.Vector3) => void;
+    BotLoaded: (model: THREE.Group<THREE.Object3DEventMap>) => void;
+}
+
+export declare interface BotOptions {
+    core: Core;
+    initPosition?: THREE.Vector3;
+    jumpHeight?: number;
+    speed?: number;
+    actionMap?: BotActionMap;
+}
+
+export declare type CameraConf = {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+
+export declare type ControlConf = {
+    target: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+
+export declare const Copy: __VLS_WithSlots_5<typeof __VLS_component_5, __VLS_Slots_5>;
+
+export declare class Core {
+    #private;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    renderer: THREE.WebGLRenderer;
+    db: Dexie & {
+        model: EntityTable<    {
+        id: string;
+        url: string;
+        data: Blob;
+        }, "id">;
+        config: EntityTable<    {
+        id: string;
+        url: string;
+        data: Record<string, unknown>;
+        }, "id">;
+    };
+    stats: Stats_2;
+    clock: THREE.Clock;
+    raycaster: THREE.Raycaster;
+    orbitCtrls: OrbitControls;
+    keyboard: {
+        ev: EventBus<{
+            [x: string]: any;
+        }>;
+        init: () => void;
+        dispose: () => void;
+    };
+    container: El;
+    loader: Loader;
+    world: World;
+    constructor();
+    init(el: HTMLElement): void;
+    once<K extends keyof ThreeEv>(event: K, callback: ThreeEv[K]): Core;
+    on<K extends keyof ThreeEv>(event: K, callback: ThreeEv[K]): Core;
+    emit<K extends keyof ThreeEv>(event: K, ...args: Parameters<ThreeEv[K]>): Core;
+    render(): void;
+    dispose(): void;
+}
+
+export declare interface CSS2DObjectOptions {
+    id: string;
+    el: HTMLElement;
+    target: CSS2DObject;
+    container: THREE.Mesh;
+}
+
 /**
  * CSS Properties
  */
@@ -78,6 +325,27 @@ declare interface CSSProperties extends CSS_2.Properties<string | number>, CSS_2
     [v: `--${string}`]: string | number | undefined;
 }
 
+export declare const db: Dexie & {
+    model: EntityTable<{
+        id: string;
+        url: string;
+        data: Blob;
+    }, "id">;
+    config: EntityTable<{
+        id: string;
+        url: string;
+        data: Record<string, unknown>;
+    }, "id">;
+};
+
+declare interface DebugPanel {
+    id: string;
+    label: string;
+    node: VNode | Component | string;
+}
+
+export declare const DialogPanel: __VLS_WithSlots_4<typeof __VLS_component_4, __VLS_Slots_4>;
+
 declare type Dir = "horizontal" | "vertical" | "any";
 
 declare interface DragAttr {
@@ -132,6 +400,52 @@ export declare interface DragOffset {
     scale: FixedArray<number, 2>;
 }
 
+export declare class El {
+    el: HTMLElement;
+    constructor(element?: HTMLElement | null);
+    setEl(el: HTMLElement): void;
+    getEl(): HTMLElement;
+    size(): ElRect;
+}
+
+export declare interface ElRect {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    x: number;
+    y: number;
+}
+
+/**
+ * @description changed origin: https://github.com/browserify/events
+ */
+declare interface EventBus<T extends Record<string, any>> {
+    setMaxListeners(n: number): void;
+    addListener<K extends keyof T>(type: K, listener: T[K]): void;
+    removeAllListeners<K extends keyof T>(type?: K): void;
+    removeListener<K extends keyof T>(type: K, listener: T[K]): void;
+    prependListener<K extends keyof T>(type: K, listener: T[K]): void;
+    emit<K extends keyof T>(type: K, ...args: Parameters<T[K]>): void;
+    /**
+     * addListener
+     */
+    on<K extends keyof T>(type: K, listener: T[K]): void;
+    /**
+     * removeListener
+     */
+    off<K extends keyof T>(type: K, listener: T[K]): void;
+    once<K extends keyof T>(type: K, listener: T[K]): void;
+}
+
+export declare function fetchRemote(url: string, onProgress?: (progress: LoadProgressData) => void): Promise<{
+    code: number;
+    msg: string;
+    data?: Blob;
+}>;
+
 /**
  * 定长数组类型
  */
@@ -139,8 +453,156 @@ declare type FixedArray<T, L extends number> = Pick<T[], Exclude<keyof T[], ArrM
     readonly length: L;
 };
 
+export declare function getModel(url: string, onProgress?: (progress: LoadProgressData) => void): Promise<{
+    code: number;
+    msg: string;
+    data?: Blob;
+}>;
+
+export declare function gradientColor(startColorHex: string, endColorHex: string, step: number): Array<string>;
+
+/**
+ * translate hex color to rgb color array
+ */
+export declare function hex2rgb(sColor: string): Array<number>;
+
 declare type InitType = "auto" | "inherit" | "initial" | "unset";
 
+export declare enum KeyCode {
+    init = "KEYBOARD:INIT",
+    keydown = "KEYBOARD:KEYDOWN",
+    keyup = "KEYBOARD:KEYUP",
+    keyStatus = "KEYBOARD:KEYSTATUS",
+    KeyWA = "KeyWA",
+    KeyWD = "KeyWD",
+    KeyAS = "KeyAS",
+    KeySD = "KeySD",
+    ShiftLeft = "ShiftLeft",
+    Space = "Space",
+    KeyW = "KeyW",
+    KeyA = "KeyA",
+    KeyS = "KeyS",
+    KeyD = "KeyD",
+    ArrowLeft = "ArrowLeft",
+    ArrowRight = "ArrowRight",
+    ArrowUp = "ArrowUp",
+    ArrowDown = "ArrowDown"
+}
+
+export declare interface LightMeta {
+    /**
+     * unique id is required
+     */
+    id: string;
+    type: LightType | string;
+    color: string | THREE.Color;
+    groundColor?: string | THREE.Color;
+    /**
+     * light helper will be created, this field control it's visibility
+     */
+    helper?: boolean;
+    helperColor?: string;
+    helperSize?: number;
+    visible?: boolean;
+    position?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotate?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    name?: string;
+    intensity?: number;
+    distance?: number;
+    angle?: number;
+    castShadow?: boolean;
+    penumbra?: number;
+    decay?: number;
+    /**
+     * if need TransformControls
+     */
+    debugger?: boolean;
+    /**
+     * debugger mode
+     */
+    mode?: TransformControlsMode;
+    [x: string]: any;
+}
+
+export declare class Lights {
+    #private;
+    ev: EventBus<any>;
+    constructor(core: Core);
+    update(meta: LightMeta): void;
+    add(meta: LightMeta): void;
+    clear(id: string): void;
+    dispose(): void;
+}
+
+export declare enum LightsEvent {
+    ObjectChange = "objectChange",
+    ObjectAdd = "objectAdd",
+    ObjectRemove = "objectRemove"
+}
+
+export declare enum LightType {
+    PointLight = "PointLight",
+    DirectionalLight = "DirectionalLight",
+    SpotLight = "SpotLight",
+    AmbientLight = "AmbientLight",
+    HemisphereLight = "HemisphereLight"
+}
+
+export declare class Loader {
+    #private;
+    private manager;
+    data: Record<string, LoadParam>;
+    private uv;
+    constructor(config?: LoaderConfig);
+    private init;
+    on<K extends keyof LoaderEvent>(event: K, callback: LoaderEvent[K]): Loader;
+    emit<K extends keyof LoaderEvent>(event: K, ...args: Parameters<LoaderEvent[K]>): Loader;
+    onProgress(url: string, loaded: number, total: number): void;
+    onStart(url: string, loaded: number, total: number): void;
+    onLoaded(): void;
+    onError(url: string): void;
+    load<T>(path: string, conf?: LoadOptions): Promise<T | null>;
+    loadGLTF(path: string, conf?: LoadOptions): Promise<GLTF | null>;
+    loadFBX(path: string, conf?: LoadOptions): Promise<THREE.Group<THREE.Object3DEventMap> | null>;
+    dispose(): void;
+}
+
+export declare type LoaderConfig = {
+    dracoLoaderPath?: string;
+};
+
+export declare type LoaderEvent = Pick<ThreeEv, "LoadError" | "LoadProgress" | "LoadStart" | "Loaded" | "Log" | "Custom">;
+
+export declare interface LoadOptions {
+    /**
+     * mark the loading progress bar is independent
+     */
+    independent?: boolean;
+}
+
+export declare type LoadParam = LoadProgressData & LoadOptions;
+
+export declare interface LoadProgressData {
+    url: string;
+    /**
+     * loaded resources' number
+     */
+    loaded: number;
+    /**
+     * total resources' number
+     */
+    total: number;
+    describe?: string;
+}
+
 export declare interface MoveHook {
     x?: (oldVal: number, newVal: number, width: number, height: number) => number;
     y?: (oldVal: number, newVal: number, width: number, height: number) => number;
@@ -159,7 +621,46 @@ export declare type MoveParams = DragAttr & {
     translateY: number;
 };
 
-export declare const ParentView: DefineComponent<    {}, void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export declare const ParentView: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+/**
+ * rad to anger
+ */
+export declare function r2a(radian: number): number;
+
+/**
+ * 远程资源,贴图,视频等
+ */
+export declare interface RemoteSrc {
+    /**
+     * resource type
+     *
+     *  1:image 2:video 3:link 4:color 5:api
+     */
+    sourceType: number;
+    objectName: string;
+    /**
+     * color will be used as texture
+     */
+    color?: string;
+    /**
+     * image/video address
+     */
+    fileUrl?: string;
+    /**
+     * other resource except image/video
+     */
+    content?: string;
+}
+
+export declare type RendererConf = {
+    clearColor: string;
+};
+
+/**
+ * tranlate rgb color to hex string
+ */
+export declare function rgb2Hex(rgb: string): string;
 
 export declare interface ScaleConfig {
     /**
@@ -277,9 +778,227 @@ export declare interface ScaleProps {
     dragTarget?: MaybeRef<HTMLElement | null | undefined>;
 }
 
+export declare class Scene {
+    model?: GLTF;
+    remoteResources: Record<string, RemoteSrc>;
+    bvh?: THREE.Mesh;
+    remoteTarget: Record<string, TargetSrc>;
+    /**
+     * when true,emit the `RendererClick` event
+     */
+    clickNotify: boolean;
+    private blobUrls;
+    readonly loader: Loader;
+    private core;
+    constructor(core: Core, loaderConfig?: LoaderConfig);
+    private createVideo;
+    /**
+     * set texture
+     */
+    setRemoteTexture(src: RemoteSrc): void;
+    /**
+     * set a anchor of an object, when click the object,the corresponding event will be triggered
+     */
+    setRemoteTarget(src: TargetSrc[] | TargetSrc): void;
+    load(gltfPath: string, conf?: LoadOptions): Promise<GLTF | undefined>;
+    setClickNotify(val?: boolean): void;
+    dispose(): void;
+    private disposeModel;
+    private clearBlob;
+    private init;
+    /**
+     * emit click event for debug
+     */
+    private onEmitClick;
+    private onTargetClick;
+    private initSceneInteraction;
+}
+
+export declare const Spinner: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:modelValue": (value: boolean) => any;
+}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
 declare enum Status {
     NORMAL = "NORMAL",
     HIDDEN = "HIDDEN"
 }
 
+export declare type TargetData = {
+    type: "TargetSrc";
+    data: TargetSrc;
+} | {
+    type: "RemoteSrc";
+    data: RemoteSrc;
+} | {
+    type: "Object";
+    data: THREE.Object3D<THREE.Object3DEventMap>;
+};
+
+export declare interface TargetSrc {
+    objectName: string;
+    data: Record<string, any>;
+}
+
+export declare interface ThreeEv {
+    /**
+     * OrbitControl trigger `change` event
+     */
+    OrbitChanged: (e: THREE.Event<"change", OrbitControls>) => void;
+    /**
+     * PointerLockControls trigger `lock` event
+     */
+    PointerLock: (e: THREE.Event<"lock", PointerLockControls>) => void;
+    /**
+     * PointerLockControls trigger `unlock` event
+     */
+    PointerUnlock: (e: THREE.Event<"unlock", PointerLockControls>) => void;
+    /**
+     * triggered before each render loop
+     */
+    Render: (delta: number) => void;
+    RendererClick: (mouse: THREE.Vector2, intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[]) => void;
+    /**
+     * triggered when window resize
+     */
+    Resize: () => void;
+    /**
+     * scene and renderer resources will be disposed
+     */
+    Dispose: () => void;
+    /**
+     * global resource loading progress
+     */
+    LoadStart: (e: LoadParam) => void;
+    /**
+     * global resource loading progress
+     */
+    LoadProgress: (e: LoadParam) => void;
+    /**
+     * global resource loading progress
+     */
+    Loaded: () => void;
+    /**
+     * global resource loading progress
+     */
+    LoadError: (url: string) => void;
+    /**
+     * log event
+     */
+    Log: (msg: {
+        code: number;
+        msg: string;
+        data?: {
+            type?: string;
+            data?: unknown;
+        };
+    }) => void;
+    /**
+     * camera params update
+     */
+    CameraUpdate: (e: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        fov?: number;
+        aspect?: number;
+        near?: number;
+        far?: number;
+    }) => void;
+    /**
+     * custom event for eventbus
+     */
+    Custom: (e: {
+        type: string;
+        data?: unknown;
+    }) => void;
+    /**
+     * when click the specified object
+     */
+    TargetClick: (e: TargetData) => void;
+    /**
+     * 场景加载完毕
+     */
+    SceneLoaded: () => void;
+}
+
+export declare const ThreePanel: __VLS_WithSlots_3<typeof __VLS_component_3, __VLS_Slots_3>;
+
+export declare type ThreePanelConf = {
+    url?: string;
+    control: ControlConf;
+    camera: CameraConf;
+    renderer: RendererConf;
+    lights: Array<LightMeta>;
+};
+
+export declare function useCollider(bot: Bot): {
+    teleport: (x: number, y: number, z: number) => void;
+    getPlayer: () => THREE.Mesh<RoundedBoxGeometry, THREE.MeshStandardMaterial, THREE.Object3DEventMap>;
+    update: (delta: number) => void;
+    init: () => void;
+    jump: () => void;
+    reset: () => void;
+    getCapsule: () => {
+        radius: number;
+        segment: THREE.Line3;
+    };
+    getTempBoxHelper: () => THREE.Box3Helper;
+    getGravity: () => number;
+    setGravity: (value: number) => void;
+    setCapsule: (raduis: number, start: THREE.Vector3Like, end: THREE.Vector3Like) => void;
+};
+
+export declare const useCSS2DRenderer: () => {
+    init: (globalWorld: World) => void;
+    createCube: () => THREE.Mesh<THREE.BoxGeometry, THREE.MeshBasicMaterial, THREE.Object3DEventMap>;
+    add: (id: string, el: HTMLElement, callback?: (delta: number, el: HTMLElement, target: CSS2DObject, container: THREE.Mesh) => void) => void;
+    remove: (id: string) => void;
+    dispose: () => void;
+};
+
+/**
+ * 动态增加debugger 面板
+ */
+export declare const useDebugger: StoreDefinition<"use-debugger", Pick<{
+panels: Reactive<DebugPanel[]>;
+addPanel: (conf: DebugPanel) => void;
+}, "panels">, Pick<{
+panels: Reactive<DebugPanel[]>;
+addPanel: (conf: DebugPanel) => void;
+}, never>, Pick<{
+panels: Reactive<DebugPanel[]>;
+addPanel: (conf: DebugPanel) => void;
+}, "addPanel">>;
+
+export declare function (preset?: Partial<Writable<DialogProps>>): any;
+
+export declare const useElement: <T extends Record<string, unknown> & VNodeProps>(node?: VNode) => {
+    el: ShallowRef<HTMLElement, HTMLElement>;
+    update: (node: VNode, prop?: T) => void;
+    updateProps: (prop: T) => void;
+};
+
+export declare function useKeyboard(): {
+    ev: EventBus_2<    {
+    [x: string]: any;
+    }>;
+    init: () => void;
+    dispose: () => void;
+};
+
+export declare interface World {
+    core: Core;
+    bot: Bot | null;
+    scene: Scene | null;
+    lights: Lights | null;
+}
+
+declare type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+
 export { }