@realsee/dnalogel 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Controller/RectangleScaleController.d.ts

@@ -0,0 +1,37 @@
+import { BaseController } from '../Base/BaseController';
+import type { RectangleScaleHelperAbstract } from '../Helper';
+import * as THREE from 'three';
+import type { Direction4 } from '../typings';
+import { Vector3 } from 'three';
+interface StartInfo {
+    startPoint: {
+        position: Vector3;
+        direction: Direction4;
+    };
+    dragPointInCenterBottom?: boolean | null;
+    dragPointInCenterLeft?: boolean | null;
+    plane: THREE.Plane;
+}
+export declare abstract class RectangleScaleController<OriginObject3D extends THREE.Object3D, PointType extends THREE.Object3D | HTMLElement> extends BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>> {
+    protected startInfo?: StartInfo;
+    constructor(...params: ConstructorParameters<typeof BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>>>);
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    protected getDragPlane(): THREE.Plane;
+    protected dragStart(mousePoint: {
+        x: number;
+        y: number;
+    }, point: {
+        position: THREE.Vector3;
+        direction: Direction4;
+    }): void;
+    protected dragging(point: {
+        x: number;
+        y: number;
+    }): false | void;
+    protected scale(raycaster: THREE.Raycaster): void;
+    protected dragEnd(): void;
+}
+export {};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Controller/RotateController.d.ts

@@ -0,0 +1,22 @@
+import { BaseController } from '../Base/BaseController';
+import type { RotateHelperAbstract } from '../Helper';
+export declare class RotateController<T extends RotateHelperAbstract = RotateHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    private lastRotation?;
+    private rotations;
+    private helperObject3DQuaternion;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    initialHelperQuaternion(): void;
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private rotate;
+    private dragEnd;
+    private getAngleHelper;
+    private setAngleHelperStart;
+    private setAngleHelperLength;
+    private setTipsAngle;
+    private setTipsPosition;
+}

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/HTML/rectangleScaleDom.d.ts

@@ -0,0 +1,11 @@
+import type { Direction4 } from '../../typings';
+interface Square {
+    element: HTMLElement;
+    direction: Direction4;
+}
+export declare function rectangleScaleDom(): {
+    container: HTMLElement;
+    squares: [Square, Square, Square, Square, Square, Square, Square, Square];
+};
+export declare function backgroundDom(): HTMLElement;
+export {};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/HTML/tipsDom.d.ts

@@ -0,0 +1,6 @@
+export declare function tipsDom(style?: Partial<CSSStyleDeclaration>): {
+    element: HTMLElement;
+    show: () => void;
+    hide: () => void;
+    setLeftTop: (left: string, top: string) => void;
+};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/HTML/utils/createElement.d.ts

@@ -0,0 +1,2 @@
+export declare function createElement(style?: Partial<CSSStyleDeclaration>, tagName?: string): HTMLElement;
+export declare function setStyle(element: HTMLElement, style?: Partial<CSSStyleDeclaration>): HTMLElement;

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/MoveHelper.d.ts

@@ -0,0 +1,13 @@
+import type { Object3D } from 'three';
+import type { Direction } from '../typings';
+import { MoveHelperAbstract } from '.';
+import { ArrowGroup } from './Objects/ArrowGroup';
+export declare class MoveHelper extends MoveHelperAbstract {
+    xArrow: ArrowGroup;
+    yArrow: ArrowGroup;
+    zArrow: ArrowGroup;
+    constructor(originObject3D: Object3D);
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+}

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/Objects/ArrowGroup.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import type { Direction } from '../../typings';
+import { DirectionGroup, DirectionMesh } from '../../utils';
+interface InstanceParameter {
+    direction: Direction;
+    color?: THREE.Color | string | number;
+}
+export declare class ArrowGroup extends DirectionGroup {
+    line: DirectionMesh<THREE.Geometry, THREE.MeshBasicMaterial>;
+    arrow: DirectionMesh<THREE.ConeGeometry, THREE.MeshBasicMaterial>;
+    private lineHeight;
+    private arrowHeight;
+    constructor(param: InstanceParameter);
+    private formatArrow;
+    private formatLine;
+}
+export {};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/OutlineHelper.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+export declare class OutlineHelper extends THREE.Group {
+    box: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
+    outline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    private originObject;
+    private positionAttribute;
+    constructor(obj: THREE.Object3D);
+    private update;
+    private createOutline;
+    private createBox;
+}

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from 'three';
+import { RectangleScaleHelperAbstract } from '.';
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type { Vector3 } from 'three';
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+declare type NonVoid<T> = T extends void ? never : T;
+declare type OriginObjectType = CSS3DObject | THREE.Object3D;
+export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObjectType> extends RectangleScaleHelperAbstract<T, HTMLElement> {
+    points: RectangleScaleHelperAbstract<THREE.Object3D, HTMLElement>['points'];
+    cornerPositions: Vector3[];
+    css3DInstance?: NonVoid<Create3DElementReturnType>;
+    get helperObject(): CSS3DObjectPlus<HTMLElement>;
+    plane?: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>;
+    private css3DRenderer;
+    private camera;
+    private scene;
+    private container;
+    private enabled;
+    constructor(originObject3D: T, container: Element, camera: THREE.Camera, scene: THREE.Scene);
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    showDraggingHelper(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: Vector3;
+        helperOrigin?: Vector3;
+    }): void;
+    updatePoints(): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    private initRectangleScaleHelper;
+    private getCornerPositions;
+    private calculatePointPosition;
+}
+export {};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/RotateHelper.d.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+import type { Object3D } from 'three';
+import { RotateHelperAbstract } from '../Base/BaseHelper';
+import type { Color, Direction } from '../typings';
+import { tipsDom } from './HTML/tipsDom';
+export declare class RotateHelper extends RotateHelperAbstract {
+    yzCircle: Circle;
+    xzCircle: Circle;
+    xyCircle: Circle;
+    xRingHelper: AxesDashedRing;
+    yRingHelper: AxesDashedRing;
+    zRingHelper: AxesDashedRing;
+    xAngleHelper: Sector;
+    yAngleHelper: Sector;
+    zAngleHelper: Sector;
+    angleTips?: ReturnType<typeof tipsDom>;
+    private container?;
+    constructor(originObject3D: Object3D, angleTipsParams?: {
+        container: HTMLElement;
+    });
+    updateAngleHelperQuaternion(): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    hide(): void;
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+    private filterRingHelper;
+    private filterAngleHelper;
+}
+declare class Circle extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    gapAngle: number;
+    geometry: THREE.RingGeometry;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+declare class AxesDashedRing extends THREE.Group {
+    direction: Readonly<Direction>;
+    constructor(options: {
+        direction: Direction;
+    });
+}
+declare class Sector extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    baseAxes: THREE.Vector3;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+export {};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/Helper/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../Base/BaseHelper';
+export * from './MoveHelper';
+export * from './RotateHelper';
+export * from './RectangleScaleHelper';
+export * from './OutlineHelper';

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/index.d.ts

@@ -0,0 +1,71 @@
+import type { OutlineHelper } from './Helper';
+import type { Object3DHelperEventMap, Object3DHelperState } from './typings';
+import type { MoveController } from './Controller/MoveController';
+import type { RotateController } from './Controller/RotateController';
+import type { BaseController } from './Base/BaseController';
+import { Subscribe } from '../Subscribe';
+interface Controllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    scaleController?: BaseController;
+}
+interface Helpers {
+    outlineHelper?: OutlineHelper;
+}
+export declare class Object3DHelper {
+    controllers: Controllers;
+    state: Object3DHelperState;
+    hooks: Subscribe<Object3DHelperEventMap>;
+    private helpers;
+    private eventListener;
+    constructor(controllers?: Controllers, helpers?: Helpers);
+    /**
+     * @description Show guide line
+     */
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Hide guide line
+     */
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Enable
+     */
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Disable
+     */
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Dispose
+     */
+    dispose(): void;
+    setState(state: Partial<Object3DHelperState>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    addControllers(controllers: Controllers): void;
+    addHelpers(helpers: Partial<{
+        [K in keyof Helpers]: Helpers[K];
+    }>): void;
+    getCurrentState(): Object3DHelperState;
+    private addEventListener;
+    private handleEnd;
+    private handleStart;
+    private setOtherHelpersVisible;
+    private handlePositionUpdate;
+    private handleScaleUpdate;
+    private handleRotateUpdate;
+    private handleEnable;
+    private handleVisible;
+    private everyControllerDo;
+    private handleDispose;
+    private actionIfStateIsEnabled;
+}
+export {};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/typings/Direction.d.ts

@@ -0,0 +1,2 @@
+export declare type Direction = 'x' | 'y' | 'z';
+export declare type Direction4 = 'nesw' | 'nwse' | 'ns' | 'ew';

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/typings/Hooks.d.ts

@@ -0,0 +1,45 @@
+import type * as THREE from 'three';
+export declare type HelperEventMap = {
+    moveStart: () => void;
+    rotateStart: () => void;
+    scaleStart: () => void;
+    positionUpdate: (position: {
+        matrix4?: THREE.Matrix4;
+    } | undefined) => void;
+    rotateUpdate: (rotate: {
+        quaternion?: THREE.Quaternion;
+        origin: THREE.Vector3;
+    } | undefined) => void;
+    scaleUpdate: (scale: {
+        matrix4?: THREE.Matrix4;
+        origin?: THREE.Vector3;
+        helperOrigin: THREE.Vector3;
+    } | undefined) => void;
+    moveEnd: () => void;
+    rotateEnd: () => void;
+    scaleEnd: () => void;
+};
+export interface Object3DHelperState {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export declare type Object3DHelperEventMap = {
+    show: (options?: {
+        userAction?: boolean;
+    }) => void;
+    hide: (options?: {
+        userAction?: boolean;
+    }) => void;
+    enable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    disable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    dispose: () => void;
+    stateChange: (params: {
+        state: Object3DHelperState;
+        prevState?: Object3DHelperState;
+    }) => void;
+};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/typings/Scissor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 显示区域裁剪参数
+ * @description
+ * 可通过初始化，或者 setScissor 方式设置
+ * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+ * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+ */
+export interface Scissor {
+    /** 距离左侧 */
+    left: number;
+    /** 距离下侧 */
+    bottom: number;
+    /** 宽度 */
+    width: number;
+    /** 高度 */
+    height: number;
+}

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/typings/index.d.ts

@@ -0,0 +1,5 @@
+import type * as THREE from 'three';
+export * from './Scissor';
+export * from './Direction';
+export * from './Hooks';
+export declare type Color = THREE.Color | string | number;

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/calculateThreeMouse.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+/**
+ * 计算 three 中的 mouse 的值
+ * @param  mouseXY - 鼠标相对屏幕位置
+ * @param  element - canvas元素（three的展示元素）
+ * @param  scissor - 屏幕剪裁
+ */
+export declare function calculateThreeMouse(originMouse: {
+    x: number;
+    y: number;
+}, element: HTMLElement): THREE.Vector2 & {
+    x: number;
+    y: number;
+};

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/direction.d.ts

@@ -0,0 +1,14 @@
+import type { Direction } from '../typings';
+import * as THREE from 'three';
+export declare class DirectionGroup extends THREE.Group {
+    direction: Direction;
+    constructor(direction?: Direction);
+}
+export declare class DirectionLine<T extends THREE.Geometry, K extends THREE.Material> extends THREE.Line<T, K> {
+    direction: Direction;
+    constructor(geometry?: T, material?: K, direction?: Direction);
+}
+export declare class DirectionMesh<T extends THREE.Geometry, K extends THREE.Material> extends THREE.Mesh<T, K> {
+    direction: Direction;
+    constructor(geometry?: T, material?: K, direction?: Direction);
+}

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/filterNotColinearPoints.d.ts

@@ -0,0 +1,2 @@
+import type { Vector3 } from 'three';
+export declare function filterNotColinearPoints(positions: Vector3[]): [Vector3, Vector3, Vector3] | void;

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/finiteNumber.d.ts

@@ -0,0 +1 @@
+export default function finiteNumber(value: number | undefined | null | void, defaultValue?: number): number;

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/getMouseRaycaster.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+export declare function getMouseRaycaster(camera: THREE.Camera, mouse: {
+    x: number;
+    y: number;
+}, element: HTMLElement): THREE.Raycaster;

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/getPoint.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+export default function getPoint(position?: THREE.Vector3, colorIndex?: number): THREE.Mesh<THREE.SphereGeometry, THREE.MeshBasicMaterial>;
+export declare function getAllMesh(): any[];

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from '../../../CSS3DRenderPlugin/utils';
+export * from './direction';
+export * from './calculateThreeMouse';
+export * from './normalPositionToPositions';
+export * from './object3DBoundingPosition';
+export * from './getMouseRaycaster';
+export * from './filterNotColinearPoints';
+export * from './vectorIsEqual';

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/negateScale.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export declare function negateScale(scale: THREE.Vector3): THREE.Vector3;

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/normalPositionToPositions.d.ts

@@ -0,0 +1,5 @@
+import type { Vector3 } from 'three';
+export declare function normalPositionToPositions(cameraPosition: Vector3, position: Vector3, normal: Vector3, config?: {
+    width?: number;
+    height?: number;
+}): [Vector3, Vector3, Vector3, Vector3];

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/object3DBoundingPosition.d.ts

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

package/dist/PanoTagPlugin/shared-utils/Object3DHelper/utils/vectorIsEqual.d.ts

@@ -0,0 +1,2 @@
+import type * as THREE from 'three';
+export declare function vectorIsEqual(vector1: THREE.Vector3, vector2: THREE.Vector3): boolean;

package/dist/PanoTagPlugin/shared-utils/Subscribe.d.ts

@@ -1,45 +1,61 @@
-declare const __EVENT__ = "__events__";
+interface EventMap {
+    [name: string]: (...args: any[]) => void | boolean;
+}
 /**
- * 订阅类。
- * 观察者模式（供前端使用），Node端推荐<a href="https://nodejs.org/api/events.html#events_class_eventemitter">EventEmitter</a>。
+ * 监听者模式
+ * @template T - 预设的监听回调类型
+ * @example
+ * ```
+ * new Subscribe<{
+ * "foo": [arg1: number, arg2: string],
+ * "bar": [arg: boolean],
+ * }>()
+ * ```
  */
-export default class Subscribe {
-    private [__EVENT__];
-    constructor();
+declare class Subscribe<T extends EventMap> {
     /**
-     * 判断是否注册时事件
-     * @param  {string|[string]}  name     事件类型
+     * 判断是否注册了事件
+     * @param name - 事件类型
      */
-    hasListener(name: string): any;
+    hasListener(name: keyof T): boolean;
     /**
      * 注册事件
-     * @param  {string|[string]}  names    事件类型
-     * @param  {function}         callback 事件回调函数
-     * @param  {any}              context  事件回调函数调用的上下文
-     * @param  {boolean}          once     是否只执行一次
+     * @param name - 事件类型
+     * @param callback - 事件回调函数
+     * @param once - 是否只执行一次
+     * @returns 解除事件
+     * @template K - 预设的监听事件名称
+     * @template C - 回调函数函数上下文
      */
-    on(names: string | string[], callback: (...args: any[]) => void, context?: any, once?: boolean): () => this;
+    on<K extends keyof T>(name: K, callback: (...args: Parameters<T[K]>) => ReturnType<T[K]>, once?: boolean): () => void;
     /**
      * 注册事件(是否只执行一次)
-     * @param  {string|[string]}  names    事件类型
-     * @param  {function}         callback 事件回调函数
-     * @param  {any}              context  事件回调函数调用的上下文
+     * @param name - 事件类型
+     * @param callback - 事件回调函数
+     * @returns 解除事件
+     * @template K - 预设的监听事件名称
+     * @template C - 回调函数函数上下文
      */
-    once(names: string | string[], callback: (...args: any[]) => void, context?: any): () => this;
+    once<K extends keyof T>(name: K, callback: (...args: Parameters<T[K]>) => ReturnType<T[K]>): () => void;
     /**
      * 解除事件
-     * @param  {string|[string]}  names    事件类型
-     * @param  {function}         callback 事件回调函数
      *
      * 如果 name 不传的话解除对应所有事件
      * 如果 name, callback 不传的话解除所有name的所有事件
+     * @param name - 事件类型
+     * @param callback - 事件回调函数
+     * @template K - 预设的监听事件名称
      */
-    off(names?: string | string[], callback?: (...args: any[]) => void): this;
+    off<K extends keyof T>(name?: K, callback?: (...args: Parameters<T[K]>) => ReturnType<T[K]>): void;
     /**
      * 触发事件
-     * @param  {string|[string]}    name      事件类型
-     * @param  {...any}             data      触发事件的数据
+     * @param name - 事件类型
+     * @param data - 触发事件的数据
+     * @returns canceled 是否被触发取消
+     * @template K - 预设的监听事件名称
      */
-    emit(name: string, ...data: any[]): boolean;
+    emit<K extends keyof T>(name: K, ...data: Parameters<T[K]>): boolean;
 }
-export {};
+export default Subscribe;
+export { Subscribe };
+export type { EventMap as SubscribeEventMap };

package/dist/PanoTagPlugin/tag.config.d.ts

@@ -0,0 +1,7 @@
+import type { Tags } from './typings';
+declare const DefaultConfig: {
+    globalConfig?: Tags['globalConfig'];
+    contentTypeConfig?: Tags['contentTypeConfig'];
+};
+export { DefaultConfig };
+export default DefaultConfig;

package/dist/PanoTagPlugin/typings/controller.d.ts

@@ -1,9 +1,11 @@
-import type { ContentType, DimensionType, PanoTagPluginController, TagId, PointType, Tag } from '../index';
+import type { PanoTagPluginController } from '../index';
+import type { ContentType, DimensionType, TagId, PointType, Tag } from '../typings';
 import type * as BasePlugin from '../../base/BasePlugin';
 import type TagContentSvelte from '../Components/Tag/index.svelte';
 import type { Vector3 } from 'three';
 import type { Create3DDomContainerReturnType } from '../../CSS3DRenderPlugin';
 import type { Writable } from 'svelte/store';
+import type { Subscribe } from '@realsee/five';
 export declare type PanoIndex = number;
 export declare type WorkCode = string;
 export declare type Hooks = InstanceType<typeof PanoTagPluginController>['hooks'];
@@ -54,6 +56,12 @@ export interface EventMap extends BasePlugin.EventMap<State> {
         userAction: boolean;
     }) => void;
 }
+export declare type TagEvents = {
+    unfolded: () => void;
+    folded: () => void;
+    show: () => void;
+    hide: () => void;
+};
 export interface TagCache {
     visible?: boolean;
     unfolded?: boolean;
@@ -66,6 +74,7 @@ export declare type TagElement<C extends ContentType = ContentType, P extends Po
         leftPercent: number;
         topPercent: number;
     };
+    clickable: boolean;
     state: {
         visible?: boolean;
         unfolded: boolean;
@@ -79,6 +88,7 @@ export declare type TagElement<C extends ContentType = ContentType, P extends Po
         initialNormal: Vector3;
         currentNormal: Vector3;
     };
+    hooks: Subscribe<TagEvents>;
 }>;
 export declare type MediaStore = Writable<{
     currentMediaUrl: string;