@realsee/five 6.0.0-alpha.0 → 6.0.0-alpha.10

package/five/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="webxr" />
+
 import * as THREE_2 from 'three';
 
 export declare interface AddableObject extends THREE_2.Object3D {
@@ -46,6 +48,13 @@ export declare class AnimationFrameLoop {
     disponse(): void;
 }
 
+export declare interface BaseEvent {
+    type: string;
+    timeStamp: number;
+    preventDefault(): void;
+    defaultPrevented: boolean;
+}
+
 export declare interface BoundingVolume {
     type: 'box' | 'sphere' | 'regin';
     applyMatrix4(matrix: THREE_2.Matrix4): this;
@@ -201,7 +210,7 @@ export declare class Clipper {
     private static sharedInstance?;
     static get shared(): Clipper;
     constructor();
-    update(clipperParameters: ClipperParameter[], camera: THREE_2.Camera): void;
+    update(clipperParameter: ClipperParameter | ClipperParameter[], camera: THREE_2.Camera): void;
     private projectPlanes;
 }
 
@@ -222,297 +231,69 @@ export declare type ControllerCustomInitTypes = {
 };
 
 export declare type ControllerEventTypes = {
-    /**
-     * 模态间切换动画开始
-     * @param panoId - 当前点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
-     */
-    initAnimationWillStart(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
-    /**
-     * 模态间切换动画结束
-     * @param panoId - 当前点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
-     */
-    initAnimationEnded(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
-    /**
-     * 意图要变化相机的可视角度 可以通过 `return false` 阻止
-     * @deprecated
-     * 建议通过 初始化设置的 `defaultFov`, `maxFov`, `minFov` 来限制
-     * @param fov - 意图要变化相机的可视角度
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsChangeCameraFov(fov: number): void | false;
-    /**
-     * 相机姿态变化
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
-     */
-    cameraUpdate(pose: Pose, userAction: boolean): void;
-    /**
-     * 相机姿态中可视角度变化
-     * @param fov - 相机的可视角度
-     * @param userAction - 是否用户触发
-     */
-    cameraFovUpdate(fov: Pose["fov"], userAction: boolean): void;
-    /**
-     * 相机姿态中相机位置变化
-     * @param offset - 相机位置
-     * @param userAction - 是否用户触发
-     */
-    cameraPositionUpdate(offset: Pose["offset"], userAction: boolean): void;
-    /**
-     * 相机姿态中相机方向变化
-     * @param coordinates - 相机姿态的俯仰角和偏航角
-     * @param userAction - 是否用户触发
-     */
-    cameraDirectionUpdate(coordinates: Pick<Pose, "longitude" | "latitude">, userAction: boolean): void;
-    /**
-     * 观察点位被选择
-     * @param panoId - 选择的点位
-     */
-    panoSelected(panoId: WorkPanoId | null): void;
-    /**
-     * 意图要移动到某个点位 可以通过 `return false` 阻止
-     * @param panoId - 图要移动到的点位
-     * @param options - 移动参数
-     * @param userAction - 是否用户触发
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void | false;
-    /**
-     * 开始加载并移动到某个观察点位
-     * @description
-     * 可 panoWillArrive 相比
-     * - moveToPano 在加载全景图资源前触发
-     * - panoWillArrive 在加载全景图资源后触发
-     * @param panoId - 移动到的点位
-     * @param userAction - 是否用户触发
-     */
-    moveToPano(panoId: WorkPanoId, userAction: boolean): void;
-    /**
-     * 开始加载某个观察点的全景资源
-     * @param panoId - 移动到的点位
-     */
-    panoWillLoad(panoId: WorkPanoId): void;
-    /**
-     * 某个观察点的全景资源加载完成
-     * @param panoId - 对应的点位
-     */
-    panoLoaded(panoId: WorkPanoId): void;
-    /**
-     * 某个观察点的全景资源加载失败
-     * @param error - 错误对象
-     * @param panoId - 对应的点位
-     */
-    panoLoadError(error: Error, panoId: WorkPanoId): void;
-    /**
-     * 移动到某个观察点位被取消
-     * @description
-     * 这个有一些情况会导致
-     * - 移动过程中切换模态
-     * - 移动过程中 five 被析构
-     * - 移动过程点击切换到另一个点位
-     * @param panoId - 对应的点位
-     */
-    moveToPanoCanceled(panoId: WorkPanoId): void;
-    /**
-     * 开始移动到某个观察点位
-     * @description
-     * 和 moveToPano 相比
-     * - moveToPano 在加载全景图资源前触发
-     * - panoWillArrive 在加载全景图资源后触发
-     * @param panoId - 移动到点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
-     */
-    panoWillArrive(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
-    /**
-     * 移动到某个观察点位
-     * @param panoIndex - 移动到点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
-     */
-    panoArrived(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
-    /**
-     * 移动中， 会告知移动状态（耗时百分比）
-     * @param panoId - 将要移动到的点位下标
-     * @param prevPanoId - 上一个点位下标
-     * @param progress - 整个过程经度 [0-1]
-     */
-    movingToPano(panoId: WorkPanoId, prevPanoId: WorkPanoId, progress: number): void;
-    /**
-     * 意图要触发手势， 可以通过 `return false` 阻止
-     * @param type - 手势类型
-     * @param pointers - 手指位置
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsGesture(type: GestureTypes, pointers: {
-        x: number;
-        y: number;
-        delta?: number;
-    }[], final: boolean): void | false;
-    /**
-     * 手势 触发
-     * @param type - 手势类型
-     * @param pointers - 手指位置
-     * @param final - 是否手势结束
-     */
-    gesture(type: GestureTypes, pointers: {
-        x: number;
-        y: number;
-        delta?: number;
-    }[], final: boolean): void;
-    /**
-     * 意图要触发 pan 手势(滑动屏幕)， 可以通过 `return false` 阻止
-     * @param pose - 意图的相机姿态
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsPanGesture(pose: Pose, final: boolean): void | false;
-    /**
-     * pan 手势(滑动屏幕) 被触发
-     * @param pose - 相机姿态
-     * @param final - 是否手势结束
-     */
-    panGesture(pose: Pose, final: boolean): void;
-    /**
-     * 意图要触发 pan 手势(滑动屏幕) 的惯性运动, 可以通过 `return false` 阻止
-     * @param pose - 意图的相机姿态
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsInteriaPan(pose: Pose): void | false;
-    /**
-     * pan 手势(滑动屏幕) 的惯性运动
-     * @param pose - 意图的相机姿态
-     * @param final - 是否手势结束
-     */
-    interiaPan(pose: Pose, final: boolean): void;
-    /**
-     * 意图要触发 tap 手势(点击屏幕)， 可以通过 `return false` 阻止
-     * @param raycaster - 点击对应的三维射线
-     * @param tapPosition - 点击对应的屏幕位置
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsTapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void | false;
-    /**
-     * tap 手势(点击屏幕) 被触发
-     * @param raycaster - 点击对应的三维射线
-     * @param tapPosition - 点击对应的屏幕位置
-     * @param final - 是否手势结束
-     */
-    tapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void;
-    /**
-     * 意图要触发 pinch 手势(双指缩放)，可以通过 `return false` 阻止
-     * @param scale - 缩放数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsPinchGesture(scale: number, nextFov: number, final: boolean): void | false;
-    /**
-     * 意图要触发 press 手势(长按屏幕)， 可以通过 `return false` 阻止
-     * @param raycaster - 长按对应的三维射线
-     * @param tapPosition - 长按对应的屏幕位置
-     * @param duration - 长按持续时间
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsPressGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, duration: number, isFinal: boolean): void | false;
-    /**
-     * tap 手势(点击屏幕) 被触发
-     * @param raycaster - 点击对应的三维射线
-     * @param tapPosition - 点击对应的屏幕位置
-     * @param duration - 长按持续时间
-     * @param final - 是否手势结束
-     */
-    pressGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, duration: number, isFinal: boolean): void;
-    /**
-     * pinch 手势(双指缩放) 被触发
-     * @param scale - 缩放数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
-     */
-    pinchGesture(scale: number, fov: number, final: boolean): void;
-    /**
-     * 意图要触发 鼠标滚轮 可以通过 `return false` 阻止
-     * @param delta - 滚轮数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsMouseWheel(delta: number, nextFov: number, final: boolean): void | false;
-    /**
-     * 鼠标滚轮被触发
-     * @param delta - 滚轮数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
-     */
-    mouseWheel(delta: number, fov: number, final: boolean): void;
-    /**
-     * 鼠标焦点环位置被重新计算
-     * @param intersection - 焦点碰撞结果
-     * @param mesh - 焦点环 mesh
-     */
-    intersectionOnModelUpdate(intersection: Intersection, mesh: IntersectMeshInterface): void;
-    /**
-     * 意图要展示鼠标焦点环，可以通过 `return false` 阻止
-     * @param intersection - 焦点碰撞结果
-     * @returns 可以通过 `return false` 阻止
-     */
-    wantsShowIntersectionOnModel(raycaster: THREE_2.Raycaster): void | false;
-    /** 鼠标焦点环被隐藏 */
-    intersectionHidden(): void;
-    /** 意图要退出VR眼镜模式 */
-    vrWantsToExit(): void;
-    /**
-     * 观察点的全景资源开始加载
-     * @param panoId - 加载点位
-     */
-    textureStartLoad(panoId: WorkPanoId): void;
-    /**
-     * 观察点的全景资源加载中，可获取到进度
-     * @param progress - 加载进度 [0-1]
-     * @param panoId - 加载点位下标
-     */
-    textureLoading(progress: number, panoId: WorkPanoId): void;
-    /**
-     * 观察点的全景资源加载被中止
-     * @param panoId - 加载点位
-     */
-    textureAbort(panoId: WorkPanoId): void;
-    /**
-     * 观察点的全景资源加载失败
-     * @param error - 错误对象
-     * @param panoId - 加载点位
-     */
-    textureError(error: Error, panoId: WorkPanoId): void;
-    /**
-     * 观察点的全景资源加载完成
-     * @param panoId - 加载点位
-     */
-    textureLoaded(panoId: WorkPanoId, meta: (NetWorkMeta | null)[]): void;
-    /**
-     * 抛出错误
-     * @param error - 抛出错误
-     */
-    error(error: Error): void;
-    /**
-     * webXR模式开始，webxr session完成坐标系矫正
-     */
-    webXRSessionStart(): void;
-    /**
-     * webXR模式结束,webxr session销毁
-     */
-    webXRSessionEnd(): void;
-    /**
-     * axes代表控制杆，axes数组的0-1元素分别代表左控制器的左（-1）右（1）,左控制器的上（-1）下（1），axes数组的2-3元素同理
-     */
-    webXRControllerEvent(type: WebXRControllerType, key: WebXRControllerKey, params: WebXRControllerParams): void;
+    /** 手势 滑动屏幕 */
+    "gesture.pan"(event: GestureEvent): void;
+    /** 手势 点击屏幕 */
+    "gesture.tap"(event: GestureEvent): void;
+    /** 手势 长按屏幕 */
+    "gesture.press"(event: GestureEvent): void;
+    /** 手势 双指缩放 */
+    "gesture.pinch"(event: GestureEvent): void;
+    /** 手势 鼠标滚轮 */
+    "gesture.mousewheel"(event: GestureEvent): void;
+    /** 手势 鼠标移动 */
+    "gesture.mousemove"(event: GestureEvent): void;
+    /** 手势 惯性 */
+    "gesture.momentum"(event: GestureEvent): void;
+    /** 模态切换动画 开始 */
+    "initAnimation.start"(event: StateEvent): void;
+    /** 模态切换动画 结束 */
+    "initAnimation.end"(event: StateEvent): void;
+    /** 相机改变 */
+    "camera.update"(event: StateEvent): void;
+    "intersect.update"(event: IntersectEvent): void;
+    /** 选择 */
+    "pano.select"(event: PanoEvent): void;
+    /** 请求点位 */
+    "pano.request"(event: PanoEvent): void;
+    /** 运动去点位 */
+    "pano.moveTo"(event: PanoEvent): void;
+    /** 运动点位过程 */
+    "pano.moving"(event: PanoEvent): void;
+    /** 运动到达点位 */
+    "pano.arrived"(event: PanoEvent): void;
+    /** 取消运动点位 */
+    "pano.cancel"(event: PanoEvent): void;
+    /** 运动点位出错 */
+    "pano.error"(event: PanoEvent): void;
+    /** 加载全景材质 */
+    "pano.texture.load"(event: PanoTextureEvent): void;
+    /** 加载全景材质进度 */
+    "pano.texture.progress"(event: PanoTextureEvent): void;
+    /** 加载全景材质成功 */
+    "pano.texture.success"(event: PanoTextureEvent): void;
+    /** 加载全景材质失败 */
+    "pano.texture.error"(event: PanoTextureEvent): void;
+    /** 加载全景材质中止 */
+    "pano.texture.abort"(event: PanoTextureEvent): void;
+    /** VRPanorama 请求退出 */
+    "vr.requestExit"(event: BaseEvent): void;
+    /** XR 退出 */
+    "xr.session.end"(event: XRSessionEvent_2): void;
+    /** XR 进入 */
+    "xr.session.start"(event: XRSessionEvent_2): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.tap"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.press"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.buttonUp"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.buttonDown"(event: XRGestureEvent): void;
+    /** XR手柄更新*/
+    "xr.controller.update"(event: XRControllerEvent): void;
+    /** 抛出错误 */
+    "error"(error: Error): void;
 };
 
 export declare class CullingVolume {
@@ -545,7 +326,7 @@ export declare interface DepthPanoramaControllerCustomInitArgs extends PanoramaL
      */
     panoTapTriggerRadius?: number;
     /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: (panoId: WorkPanoId) => PanoCircleMeshInterface;
+    panoCircleMeshCreator?: (pano: Pano) => PanoCircleMeshInterface;
 }
 
 /**
@@ -561,150 +342,51 @@ export declare interface EventCallback extends EventTypes {
  * @description
  * 具体事件列表 请查看 {@link EventCallback}
  */
-export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROLLER_EVENT_NAMES[number]> & {
-    /**
-     * 内部错误
-     * @param error - 错误对象
-     */
-    error(error: Error): void;
-    /**
-     * 准备加载 Work 数据
-     * @param input - 输入的 work
-     * @param works - 归一化的标准 work
-     * @param state - 加载时的姿态
-     */
-    willLoad(input: any, works: Works, state: Partial<State>): void;
-    /**
-     * 开始加载 Work 数据
-     * @param input - 输入的 work
-     * @param works - 归一化的标准 work
-     * @param state - 加载时的姿态
-     */
-    load(input: any, works: Works, state: Partial<State>): void;
-    /**
-     * 加载完 Work 数据
-     * @param input - 输入的 work
-     * @param works - 归一化的标准 work
-     */
-    loaded(input: any, works: Works): void;
-    /**
-     * 模型开始加载
-     * @param workModel - 归一化的标准 work 中的 model 值
-     */
-    modelWillLoad(workModel: WorkModel): void;
-    /**
-     * 模型三角面片结构加载完成
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelGeometryLoaded(model: Model): void;
-    /**
-     * 模型材质结构加载完成
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelMaterialLoaded(model: Model): void;
-    /**
-     * 模型 bvh树 计算完成
-     * @description
-     * bvh 树用于高效的碰撞检测，可以在 `model.bvh` 属性来设置是否开启。默认开启。
-     * bvh 树计算需要一定事件，可能会暂时影响一些性能。计算完毕后，会对碰撞检测带来质的提升。
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelBvhLoaded(model: Model): void;
-    /**
-     * 模型加载错误
-     * @param error - 错误对象
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelLoadError(error: Error, model: Model): void;
-    /**
-     * 模型加载完成
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelLoaded(model: Model): void;
-    /**
-     * 模型楼层切换
-     * @param shownFloor - 模型楼层
-     */
-    modelShownFloorChange(shownFloor: number | null, totalFloorLength: number): void;
-    /**
-     * 渲染循环
-     * @param rendered - 是否渲染了
-     */
-    renderFrame(rendered: boolean): void;
-    /**
-     * 当前 fps 变化
-     * @param fps - 当前刷新率
-     */
-    fps(fps: number): void;
-    /**
-     * 当目标 state 变化时
-     * @param state - 当前姿态状态
-     * @param userAction - 是否用户触发
-     */
-    stateChange(state: State, userAction: boolean): void;
-    /**
-     * 当前实时 state 变化时
-     * @param state - 当前姿态状态
-     * @param userAction - 是否用户触发
-     */
-    currentStateChange(state: State, userAction: boolean): void;
-    /**
-     * 当 setState 方法被调用
-     * @param state - 当前姿态状态
-     */
-    setState(state: State): void;
-    /**
-     * 当 state 被同步完成时
-     * @param state - 当前姿态状态
-     */
-    stateSynced(state: State): void;
-    /**
-     * 意图要移动到某个点时, 可以通过 return false 阻止
-     * @param panoId - 意图要移动到点位
-     * @param options - 移动参数
-     * @param userAction - 是否用户触发
-     * @returns 可以通过 return false 阻止
-     */
-    wantsMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void | false;
-    /**
-     * 同 wantsMoveToPano
-     * @description
-     * @param panoId - 意图要移动到点位
-     * @param options - 移动参数
-     * @param userAction - 是否用户触发
-     * @returns 可以通过 return false 阻止
-     */
-    wantsToMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void;
-    /**
-     * 意图要切换到某个模态， 可以通过 return false 阻止
-     * @param mode - 意图要切换到的模态
-     * @param prevMode - 当前模态
-     * @returns 可以通过 return false 阻止
-     */
-    wantsChangeMode(mode: Mode, prevMode: Mode): void | false;
-    /**
-     * 模态切换完成
-     * @param mode - 切换到的模态
-     * @param prevMode - 上本质是一个模态
-     * @param panoIndex - 初始化动画结束后的点位下标
-     * @param toPose - 初始化动画结束后的状态
-     * @param userAction - 是否用户触发
-     */
-    modeChange(mode: Mode, prevMode: Mode, panoId: WorkPanoId, toPose: Pose, userAction: boolean): void;
-    /**
-     * 帮助元素显应的变换
-     * @param visible - 帮助元素的是否开启
-     */
-    helpersVisibleChange(visible: boolean): void;
-    /**
-     * 网络资源分析
-     * @param source - 资源地址
-     * @param state - 状态
-     * @param detail - 详情
-     */
-    network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
+export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROLLER_EVENT_NAMES[number]> & LegacyEventType & {
+    /** 请求点位 */
+    "pano.request"(event: PanoEvent): void;
+    /** 内部错误 */
+    "error"(error: Error): void;
+    /** 请求 work数据 */
+    "works.request"(event: WorksEvent): void;
+    /** 加载 work */
+    "works.load"(event: WorksEvent): void;
+    /** 加载 work 并 controller ready */
+    "works.ready"(event: WorksEvent): void;
+    /** 设置 state */
+    "state.set"(event: StateEvent): void;
+    /** 当 state 变化 */
+    "state.change"(event: StateEvent): void;
+    /** 当 state 同步完成 */
+    "state.synced"(event: StateEvent): void;
+    /** 当前 state 变化 */
+    "currentState.change"(event: StateEvent): void;
+    /** 当模型加载 */
+    "model.request"(event: ModelEvent): void;
+    /** 当模型修改楼层 */
+    "model.load"(event: ModelEvent): void;
+    /** 当模型错误 */
+    "model.error"(event: ModelEvent): void;
+    /** 当模型修改楼层 */
+    "model.changeShownFloor"(event: ModelEvent): void;
+    /** 模型加载完成 */
+    "models.load"(event: ModelsEvent): void;
+    /** 渲染前 */
+    "render.prepare"(event: RenderEvent): void;
+    /** 渲染后 */
+    "render"(event: RenderEvent): void;
+    /** 请求改变 mode */
+    "mode.change.request"(event: ModeChangeEvent): void;
+    /** 改变 mode */
+    "mode.change"(event: ModeChangeEvent): void;
+    /** 改变 helpers 元素可见 */
+    "helpers.visible"(event: ObjectEvent): void;
+    /** 网络资源 */
+    "network.resource"(event: NetworkResourceEvent): void;
+    /** 当前 fps 变化 */
+    "fps"(fps: number): void;
     /** five 被析构。 插件中请监听用于自身析构 */
-    dispose(): void;
+    "dispose"(): void;
 };
 
 /**
@@ -750,11 +432,13 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     paused: boolean;
     /** 当前点位序号 */
-    panoId: WorkPanoId;
+    pano: Pano;
     /** 当前展示的模式 */
     currentMode: Mode;
     /** 内部使用的 `THREE.Scene` */
     scene: Scene;
+    /** 供外部放置需要在xr场景下产生遮挡的物体们*/
+    xrCustomObjectsScene: THREE_2.Scene;
     /** 内部使用的 `Camera` */
     camera: Camera;
     /**
@@ -777,7 +461,8 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     renderer?: THREE_2.WebGLRenderer;
     /** 当前加载的模型 */
-    model: Model;
+    models: Models;
+    private lastModels;
     /**
      * 是否需要渲染
      * @description
@@ -831,6 +516,19 @@ export declare class Five extends Subscribe<EventTypes> {
      * ```
      */
     state: State;
+    info: null | {
+        memory: {
+            geometries: number;
+            textures: number;
+        };
+        render: {
+            calls: number;
+            frame: number;
+            lines: number;
+            points: number;
+            triangles: number;
+        };
+    };
     /** 插件暴露的方法 */
     plugins: {
         [key: string]: FivePluginInstance<any>;
@@ -840,6 +538,7 @@ export declare class Five extends Subscribe<EventTypes> {
     private boundingMesh;
     private stopAnimationLoop?;
     private fps;
+    private modelGroup;
     private helperGroup;
     private modeChangeDuration;
     private onlyRenderIfNeeds;
@@ -851,7 +550,6 @@ export declare class Five extends Subscribe<EventTypes> {
     private extraElements;
     private getPixelsRenderTarget;
     private readyCallbacks;
-    private modelPending;
     private syncingState;
     /**
      * 是否开启 IOS EDR 模式
@@ -916,11 +614,17 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     get enableIOSEDR(): boolean;
     set enableIOSEDR(enable: boolean);
+    /**
+     * 后处理类型
+     */
+    get postProcessingType(): PostProcessingType;
     /**
      * 是否开启EDL模式
      */
     get enableEDL(): boolean;
     set enableEDL(enable: boolean);
+    get enableHQ(): boolean;
+    set enableHQ(enable: boolean);
     /**
      * 是否开启后处理
      */
@@ -1010,6 +714,7 @@ export declare class Five extends Subscribe<EventTypes> {
     /** 当前加载的 work 数据 */
     get works(): Works;
     get work(): Work | undefined;
+    get model(): Model;
     /**
      * 加载 Work 数据
      * @param inputWork - Work 数据
@@ -1044,6 +749,10 @@ export declare class Five extends Subscribe<EventTypes> {
      * 获取显示用的画布（Canvas DOM节点）
      */
     getElement(): HTMLCanvasElement | undefined;
+    /**
+     * 获取观测点
+     */
+    get observers(): WorkResolvedObserver[];
     /**
      * 强制渲染
      * @description
@@ -1068,16 +777,14 @@ export declare class Five extends Subscribe<EventTypes> {
      * @param options - 移动点位参数
      * @param userAction - 是否用户触犯
      */
-    moveToPano(panoId: WorkPanoId, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
-    moveToPano(panoIndex: number, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
+    moveToPano(pano: Pano | PanoId | number, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
     /**
      * 预加载点位图片资源
-     * @param panoIndex - 观察点序号
+     * @param pano - 观察点序号
      * @param callback - 加载完成回调, 并传递加载用时。
      * @returns 加载完成的 Promise 参数同 callback
      */
-    preloadPano(panoId: WorkPanoId, callback?: (costs: number) => void): Promise<number>;
-    preloadPano(panoIndex: number, callback?: (costs: number) => void): Promise<number>;
+    preloadPano(pano: Pano | PanoId | number, callback?: (costs: number) => void): Promise<number>;
     /**
      * 计算三维坐标对应到屏幕的二维坐标
      * @description
@@ -1137,8 +844,6 @@ export declare class Five extends Subscribe<EventTypes> {
     private applyController;
     /** 移除事件绑定 */
     private removeEventListeners;
-    /** 销毁GPU Picking 所用的材质 */
-    private diposeGPUPickingMaterial;
 }
 
 /** Five 初始化参数 */
@@ -1347,7 +1052,36 @@ export declare interface FloorplanControllerCustomInitArgs {
     intersectMeshCreator?: () => IntersectMeshInterface;
 }
 
-export declare type GestureTypes = "pan" | "tap" | "pinch" | "press" | "mouseWheel";
+export declare interface GestureEvent extends StateEvent {
+    target: EventTarget | null;
+    pointerType: 'touch' | 'pen' | 'mouse' | 'kinect';
+    srcEvent: MouseEvent | TouchEvent | PointerEvent;
+    pointers: {
+        x: number;
+        y: number;
+        delta: number;
+        buttons: number;
+        coords: THREE_2.Vector2;
+        raycaster: THREE_2.Raycaster;
+    }[];
+    isFirst: boolean;
+    isFinal: boolean;
+    scale: number;
+    center: {
+        x: number;
+        y: number;
+        delta: number;
+        buttons: number;
+        coords: THREE_2.Vector2;
+        raycaster: THREE_2.Raycaster;
+    };
+    velocityX: number;
+    velocityY: number;
+    overallVelocityX: number;
+    overallVelocityY: number;
+}
+
+export declare type GestureTypes = "pan" | "tap" | "pinch" | "press" | "mouseWheel" | "mouseMove";
 
 export declare function getViewportScale(): number;
 
@@ -1356,90 +1090,504 @@ export declare function getViewportScale(): number;
  */
 export declare interface ImageOptions {
     /**
-     * url 地址转化
-     * @param url - 原始地址
-     * @param options - 当前地址参数
-     * @returns 转化后地址
+     * url 地址转化
+     * @param url - 原始地址
+     * @param options - 当前地址参数
+     * @returns 转化后地址
+     */
+    transform?: (url: string, options: ImageURLOptions) => string;
+    /** 图片尺寸参数 尽量使用 2 的幂次 如 512 1024 2048 */
+    size?: number;
+    /** 图片质量参数(0-100) */
+    quality?: number;
+    /** 图片格式参数 */
+    format?: "jpg" | "png" | "heif" | "webp" | "avif";
+    /** 锐化参数 海外不支持 */
+    sharpen?: number;
+    mappings?: ImageURLMappings;
+}
+
+export declare function imageSupport(): Promise<{
+    avif: boolean;
+    webp: boolean;
+}>;
+
+export declare interface ImageURLMappings {
+    [publicDomain: string]: {
+        "type"?: string;
+        "pano": [string, string];
+        "tile": [string, string];
+        "model": [string, string];
+        "texture": [string];
+        "default": [string];
+    };
+}
+
+export declare interface ImageURLOptions {
+    /** 图片类型标识 */
+    key: string;
+    /** 图片尺寸参数 尽量使用 2 的幂次 如 256 512 1024 */
+    size?: number;
+    /** 图片质量参数(0-100) */
+    quality?: number;
+    /** 图片格式参数 */
+    format?: "jpg" | "png" | "heif" | "webp" | "avif";
+    /** 图片裁切 */
+    cut?: [x: number, y: number, width: number, height: number];
+    /** 锐化参数 海外不支持 */
+    sharpen?: number;
+    /** url匹配规则 */
+    mappings?: ImageURLMappings;
+}
+
+export declare class InternalWebGLRenderer extends THREE_2.WebGLRenderer {
+    constructor({ preserveDrawingBuffer, backgroundColor, backgroundAlpha, pixelRatio, antialias, webgl2, }: {
+        preserveDrawingBuffer?: boolean;
+        backgroundColor?: number | THREE_2.Color;
+        backgroundAlpha?: number;
+        pixelRatio?: number;
+        antialias?: boolean;
+        webgl2?: boolean;
+    });
+}
+
+export declare interface IntersectEvent extends BaseEvent {
+    object: THREE_2.Object3D;
+    raycaster: THREE_2.Raycaster;
+    intersection: Intersection | null;
+}
+
+export declare interface Intersection {
+    /** 焦点坐标 */
+    point: THREE.Vector3;
+    /** 焦点面片 */
+    face?: {
+        normal: THREE.Vector3;
+    } | null;
+    /** 焦点距离 */
+    distance: number;
+}
+
+export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
+    private ringMesh;
+    constructor();
+    dispose(): void;
+}
+
+/**
+ * 地面提示点位接口
+ */
+export declare interface IntersectMeshInterface extends THREE_2.Object3D {
+    dispose(): void;
+}
+
+export declare function isPanoId(id: any): id is PanoId;
+
+/**
+ * 过时的事件列表
+ */
+export declare type LegacyEventType = {
+    /**
+     * 模态间切换动画开始
+     * @param panoIndex - 当前点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
+     */
+    initAnimationWillStart(panoIndex: number, pose: Pose, userAction: boolean): void;
+    /**
+     * 模态间切换动画结束
+     * @param panoIndex - 当前点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
+     */
+    initAnimationEnded(panoIndex: number, pose: Pose, userAction: boolean): void;
+    /**
+     * 意图要触发手势， 可以通过 `return false` 阻止
+     * @param type - 手势类型
+     * @param pointers - 手指位置
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsGesture(type: GestureTypes, pointers: {
+        x: number;
+        y: number;
+        delta?: number;
+    }[], final: boolean): void | false;
+    /**
+     * 手势 触发
+     * @param type - 手势类型
+     * @param pointers - 手指位置
+     * @param final - 是否手势结束
+     */
+    gesture(type: GestureTypes, pointers: {
+        x: number;
+        y: number;
+        delta?: number;
+    }[], final: boolean): void;
+    /**
+     * 意图要触发 pan 手势(滑动屏幕)， 可以通过 `return false` 阻止
+     * @param pose - 意图的相机姿态
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsPanGesture(pose: Pose, final: boolean): void | false;
+    /**
+     * pan 手势(滑动屏幕) 被触发
+     * @param pose - 相机姿态
+     * @param final - 是否手势结束
+     */
+    panGesture(pose: Pose, final: boolean): void;
+    /**
+     * 意图要触发 tap 手势(点击屏幕)， 可以通过 `return false` 阻止
+     * @param raycaster - 点击对应的三维射线
+     * @param tapPosition - 点击对应的屏幕位置
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsTapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void | false;
+    /**
+     * tap 手势(点击屏幕) 被触发
+     * @param raycaster - 点击对应的三维射线
+     * @param tapPosition - 点击对应的屏幕位置
+     * @param final - 是否手势结束
+     */
+    tapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void;
+    /**
+     * 意图要触发 pinch 手势(双指缩放)，可以通过 `return false` 阻止
+     * @param scale - 缩放数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsPinchGesture(scale: number, nextFov: number, final: boolean): void | false;
+    /**
+     * 意图要触发 press 手势(长按屏幕)， 可以通过 `return false` 阻止
+     * @param raycaster - 长按对应的三维射线
+     * @param tapPosition - 长按对应的屏幕位置
+     * @param duration - 长按持续时间
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsPressGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, duration: number, isFinal: boolean): void | false;
+    /**
+     * tap 手势(点击屏幕) 被触发
+     * @param raycaster - 点击对应的三维射线
+     * @param tapPosition - 点击对应的屏幕位置
+     * @param duration - 长按持续时间
+     * @param final - 是否手势结束
+     */
+    pressGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, duration: number, isFinal: boolean): void;
+    /**
+     * pinch 手势(双指缩放) 被触发
+     * @param scale - 缩放数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
+     */
+    pinchGesture(scale: number, fov: number, final: boolean): void;
+    /**
+     * 意图要触发 鼠标滚轮 可以通过 `return false` 阻止
+     * @param delta - 滚轮数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsMouseWheel(delta: number, nextFov: number, final: boolean): void | false;
+    /**
+     * 鼠标滚轮被触发
+     * @param delta - 滚轮数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
+     */
+    mouseWheel(delta: number, fov: number, final: boolean): void;
+    /**
+     * 意图要触发 pan 手势(滑动屏幕) 的惯性运动, 可以通过 `return false` 阻止
+     * @param pose - 意图的相机姿态
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsInteriaPan(pose: Pose): void | false;
+    /**
+     * pan 手势(滑动屏幕) 的惯性运动
+     * @param pose - 意图的相机姿态
+     * @param final - 是否手势结束
+     */
+    interiaPan(pose: Pose, final: boolean): void;
+    /**
+     * 意图要变化相机的可视角度 可以通过 `return false` 阻止
+     * @deprecated
+     * 建议通过 初始化设置的 `defaultFov`, `maxFov`, `minFov` 来限制
+     * @param fov - 意图要变化相机的可视角度
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsChangeCameraFov(fov: number): void | false;
+    /**
+     * 相机姿态变化
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
+     */
+    cameraUpdate(pose: Pose, userAction: boolean): void;
+    /**
+     * 相机姿态中可视角度变化
+     * @param fov - 相机的可视角度
+     * @param userAction - 是否用户触发
+     */
+    cameraFovUpdate(fov: Pose["fov"], userAction: boolean): void;
+    /**
+     * 相机姿态中相机位置变化
+     * @param offset - 相机位置
+     * @param userAction - 是否用户触发
+     */
+    cameraPositionUpdate(offset: Pose["offset"], userAction: boolean): void;
+    /**
+     * 相机姿态中相机方向变化
+     * @param coordinates - 相机姿态的俯仰角和偏航角
+     * @param userAction - 是否用户触发
+     */
+    cameraDirectionUpdate(coordinates: Pick<Pose, "longitude" | "latitude">, userAction: boolean): void;
+    /**
+     * 鼠标焦点环位置被重新计算
+     * @param intersection - 焦点碰撞结果
+     * @param mesh - 焦点环 mesh
+     */
+    intersectionOnModelUpdate(intersection: Intersection, mesh: THREE_2.Object3D): void;
+    /**
+     * 意图要展示鼠标焦点环，可以通过 `return false` 阻止
+     * @param intersection - 焦点碰撞结果
+     * @returns 可以通过 `return false` 阻止
+     */
+    wantsShowIntersectionOnModel(raycaster: THREE_2.Raycaster): void | false;
+    /** 鼠标焦点环被隐藏 */
+    intersectionHidden(): void;
+    /**
+     * 意图要移动到某个点时, 可以通过 return false 阻止
+     * @param panoIndex - 意图要移动到点位
+     * @param options - 移动参数
+     * @param userAction - 是否用户触发
+     * @returns 可以通过 return false 阻止
+     */
+    wantsMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void | false;
+    /**
+     * 同 wantsMoveToPano
+     * @description
+     * @param panoIndex - 意图要移动到点位
+     * @param options - 移动参数
+     * @param userAction - 是否用户触发
+     * @returns 可以通过 return false 阻止
+     */
+    wantsToMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void;
+    /**
+     * 观察点位被选择
+     * @param panoIndex - 选择的点位
+     */
+    panoSelected(panoIndex: number | null): void;
+    /**
+     * 开始加载并移动到某个观察点位
+     * @description
+     * 可 panoWillArrive 相比
+     * - moveToPano 在加载全景图资源前触发
+     * - panoWillArrive 在加载全景图资源后触发
+     * @param panoIndex - 移动到的点位
+     * @param userAction - 是否用户触发
+     */
+    moveToPano(panoIndex: number, userAction: boolean): void;
+    /**
+     * 移动中， 会告知移动状态（耗时百分比）
+     * @param panoIndex - 将要移动到的点位下标
+     * @param prevPanoIndex - 上一个点位下标
+     * @param progress - 整个过程经度 [0-1]
+     */
+    movingToPano(panoIndex: number, prevPanoIndex: number, progress: number): void;
+    /**
+     * 开始加载某个观察点的全景资源
+     * @param pano - 移动到的点位
+     */
+    panoWillLoad(panoIndex: number): void;
+    /**
+     * 某个观察点的全景资源加载完成
+     * @param panoIndex - 对应的点位
+     */
+    panoLoaded(panoIndex: number): void;
+    /**
+     * 开始移动到某个观察点位
+     * @description
+     * 和 moveToPano 相比
+     * - moveToPano 在加载全景图资源前触发
+     * - panoWillArrive 在加载全景图资源后触发
+     * @param panoIndex - 移动到点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
+     */
+    panoWillArrive(panoIndex: number, pose: Pose, userAction: boolean): void;
+    /**
+     * 移动到某个观察点位
+     * @param panoIndex - 移动到点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
+     */
+    panoArrived(panoIndex: number, pose: Pose, userAction: boolean): void;
+    /**
+     * 某个观察点的全景资源加载失败
+     * @param error - 错误对象
+     * @param panoIndex - 对应的点位
+     */
+    panoLoadError(error: Error, panoIndex: number): void;
+    /**
+     * 移动到某个观察点位被取消
+     * @description
+     * 这个有一些情况会导致
+     * - 移动过程中切换模态
+     * - 移动过程中 five 被析构
+     * - 移动过程点击切换到另一个点位
+     * @param panoIndex - 对应的点位
+     */
+    moveToPanoCanceled(panoIndex: number): void;
+    /**
+     * 观察点的全景资源开始加载
+     * @param panoIndex - 加载点位
+     */
+    textureStartLoad(panoIndex: number): void;
+    /**
+     * 观察点的全景资源加载中，可获取到进度
+     * @param progress - 加载进度 [0-1]
+     * @param panoIndex - 加载点位下标
+     */
+    textureLoading(progress: number, panoIndex: number): void;
+    /**
+     * 观察点的全景资源加载被中止
+     * @param panoIndex - 加载点位
+     */
+    textureAbort(panoIndex: number): void;
+    /**
+     * 观察点的全景资源加载失败
+     * @param error - 错误对象
+     * @param panoIndex - 加载点位
+     */
+    textureError(error: Error, panoIndex: number): void;
+    /**
+     * 观察点的全景资源加载完成
+     * @param panoIndex - 加载点位
+     */
+    textureLoaded(panoIndex: number, meta: (NetWorkMeta | null)[]): void;
+    /**
+     * webXR模式开始，webxr session完成坐标系矫正
+     */
+    webXRSessionStart(): void;
+    /**
+     * webXR模式结束,webxr session销毁
+     */
+    webXRSessionEnd(): void;
+    /**
+     * axes代表控制杆，axes数组的0-1元素分别代表左控制器的左（-1）右（1）,左控制器的上（-1）下（1），axes数组的2-3元素同理
+     */
+    webXRControllerEvent(type: WebXRControllerType, key: WebXRControllerKey, params: WebXRControllerParams): void;
+    /**
+     * xr控制器的Axes原始实时数据状态
+     */
+    webXRAxesUpdate(type: 'left' | 'right', param: WebXRAxesParams): void;
+    /**
+     * xr控制器的控制器射线更新
+     */
+    webXRControllerRayUpdate(raycaster: {
+        leftRay: THREE_2.Raycaster;
+        rightRay: THREE_2.Raycaster;
+    }): void;
+    /**
+     * 准备加载 Work 数据
+     * @param input - 输入的 work
+     * @param work - 归一化的标准 work
+     * @param state - 加载时的姿态
+     */
+    willLoad(input: any, work: Work, state: Partial<State>): void;
+    /**
+     * 开始加载 Work 数据
+     * @param input - 输入的 work
+     * @param work - 归一化的标准 work
+     * @param state - 加载时的姿态
+     */
+    load(input: any, work: Work, state: Partial<State>): void;
+    /**
+     * 加载完 Work 数据
+     * @param input - 输入的 work
+     * @param work - 归一化的标准 work
+     */
+    loaded(input: any, work: Work): void;
+    /**
+     * 当目标 state 变化时
+     * @param state - 当前姿态状态
+     * @param userAction - 是否用户触发
+     */
+    stateChange(state: State, userAction: boolean): void;
+    /**
+     * 当前实时 state 变化时
+     * @param state - 当前姿态状态
+     * @param userAction - 是否用户触发
+     */
+    currentStateChange(state: State, userAction: boolean): void;
+    /**
+     * 当 setState 方法被调用
+     * @param state - 当前姿态状态
+     */
+    setState(state: State): void;
+    /**
+     * 当 state 被同步完成时
+     * @param state - 当前姿态状态
+     */
+    stateSynced(state: State): void;
+    /**
+     * 模型开始加载
+     * @param workModel - 归一化的标准 work 中的 model 值
+     */
+    modelWillLoad(workModel: WorkModel): void;
+    /**
+     * 模型加载错误
+     * @param error - 错误对象
+     * @param model - 加载完的 model
+     */
+    modelLoadError(error: Error, model: Model): void;
+    /**
+     * 模型加载完成
+     * @param models - 加载完的 model
+     */
+    modelLoaded(model: Model): void;
+    /**
+     * 模型楼层切换
+     * @param shownFloor - 模型楼层
+     */
+    modelShownFloorChange(shownFloor: number | null, floorLength: number): void;
+    /**
+     * 渲染循环
+     * @param rendered - 是否渲染了
      */
-    transform?: (url: string, options: ImageURLOptions) => string;
-    /** 图片尺寸参数 尽量使用 2 的幂次 如 512 1024 2048 */
-    size?: number;
-    /** 图片质量参数(0-100) */
-    quality?: number;
-    /** 图片格式参数 */
-    format?: "jpg" | "png" | "heif" | "webp" | "avif";
-    /** 锐化参数 海外不支持 */
-    sharpen?: number;
-    mappings?: ImageURLMappings;
-}
-
-export declare function imageSupport(): Promise<{
-    avif: boolean;
-    webp: boolean;
-}>;
-
-export declare interface ImageURLMappings {
-    [publicDomain: string]: {
-        "type"?: string;
-        "pano": [string, string];
-        "tile": [string, string];
-        "model": [string, string];
-        "texture": [string];
-        "default": [string];
-    };
-}
-
-export declare interface ImageURLOptions {
-    /** 图片类型标识 */
-    key: string;
-    /** 图片尺寸参数 尽量使用 2 的幂次 如 256 512 1024 */
-    size?: number;
-    /** 图片质量参数(0-100) */
-    quality?: number;
-    /** 图片格式参数 */
-    format?: "jpg" | "png" | "heif" | "webp" | "avif";
-    /** 图片裁切 */
-    cut?: [x: number, y: number, width: number, height: number];
-    /** 锐化参数 海外不支持 */
-    sharpen?: number;
-    /** url匹配规则 */
-    mappings?: ImageURLMappings;
-}
-
-export declare class InternalWebGLRenderer extends THREE_2.WebGLRenderer {
-    constructor({ preserveDrawingBuffer, backgroundColor, backgroundAlpha, pixelRatio, antialias, webgl2, }: {
-        preserveDrawingBuffer?: boolean;
-        backgroundColor?: number | THREE_2.Color;
-        backgroundAlpha?: number;
-        pixelRatio?: number;
-        antialias?: boolean;
-        webgl2?: boolean;
-    });
-}
-
-export declare interface Intersection {
-    /** 焦点坐标 */
-    point: THREE.Vector3;
-    /** 焦点面片 */
-    face?: {
-        normal: THREE.Vector3;
-    } | null;
-    /** 焦点距离 */
-    distance: number;
-}
-
-export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
-    private ringMesh;
-    constructor();
-    dispose(): void;
-}
-
-/**
- * 地面提示点位接口
- */
-export declare interface IntersectMeshInterface extends THREE_2.Object3D {
-    dispose(): void;
-}
+    renderFrame(rendered: boolean): void;
+    /**
+     * 意图要切换到某个模态， 可以通过 return false 阻止
+     * @param mode - 意图要切换到的模态
+     * @param prevMode - 当前模态
+     * @returns 可以通过 return false 阻止
+     */
+    wantsChangeMode(mode: Mode, prevMode: Mode): void | false;
+    /**
+     * 模态切换完成
+     * @param mode - 切换到的模态
+     * @param prevMode - 上本质是一个模态
+     * @param panoIndex - 初始化动画结束后的点位下标
+     * @param toPose - 初始化动画结束后的状态
+     * @param userAction - 是否用户触发
+     */
+    modeChange(mode: Mode, prevMode: Mode, panoIndex: number, toPose: Pose, userAction: boolean): void;
+    /**
+     * 帮助元素显应的变换
+     * @param visible - 帮助元素的是否开启
+     */
+    helpersVisibleChange(visible: boolean): void;
+    /**
+     * 网络资源分析
+     * @param source - 资源地址
+     * @param state - 状态
+     * @param detail - 详情
+     */
+    network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
+};
 
 export declare type LooseWork = {
     work_code?: string;
@@ -1471,8 +1619,19 @@ export declare type LooseWorkModel = {
     material_textures?: string[];
     material_base_url?: string;
     tiles?: {
+        type?: 'point_cloud' | 'mesh' | string;
+        name?: string;
+        up_axis?: string;
         tileset_url: string;
     };
+    layers?: [
+        {
+        type?: 'point_cloud' | 'mesh' | string;
+        name?: string;
+        up_axis?: string;
+        tileset_url: string;
+    }
+    ];
 };
 
 export declare type LooseWorkObserver = {
@@ -1580,6 +1739,11 @@ export declare type Mode =
 /** XR眼镜模式*/
 "XRPanorama";
 
+export declare interface ModeChangeEvent extends StateEvent {
+    prevMode: Mode;
+    mode: Mode;
+}
+
 /**
  * Five 模型
  * @description
@@ -1588,14 +1752,23 @@ export declare type Mode =
  * 需要满足 your/path/filename.at3d.json_xxxxxx,
  * 通过 json_xxxxxx(<dataURL>) 方式返回。
  */
-export declare class Model extends PBMContainer implements Subscribe<ModelEventType> {
-    static get dracoPath(): string;
-    static set dracoPath(path: string);
+export declare class Model extends THREE_2.Object3D {
+    /** work */
+    work: Work | null;
+    /** 模型的不同图层 */
+    viewLayers: {
+        name: string;
+        type: string;
+        upAxis: string;
+        coordinates: string;
+        scene: Tile3DModel;
+    }[];
+    onError: (error: Error) => void;
+    onShownFloorChange: (floorIndex: number | null) => void;
+    onLoad: () => void;
     /** 外接盒子的大小 */
     bounding: THREE_2.Box3;
-    /** 当前显示的楼层 */
-    shownFloor: number | null;
-    /** 楼层的数量 */
+    /** 所有楼层 */
     floorLength: number;
     /** 材质贴图参数 */
     textureOptions: TextureOptions;
@@ -1603,45 +1776,47 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
     refined: boolean;
     /** 模型已经加载 */
     loaded: boolean;
+    /** 当前样式参数 */
+    materialVersion: string;
+    private _materialValues;
+    private _materialVersionMap;
+    private _floorIndex;
+    private _clippers;
+    /** 样式缓存 */
+    private cache;
+    needsRender: boolean;
+    private disposed;
+    constructor(options?: {
+        onError?: (error: Error) => void;
+        onShownFloorChange?: (floorIndex: number | null) => void;
+        onLoad?: () => void;
+    });
+    get empty(): boolean;
+    /** 获取材质参数 */
+    getMaterial(): ModelMaterialValues;
+    /** 设置材质参数 */
+    setMaterial(values: Partial<ModelMaterialValues>): void;
     /**
-     * 判断是否注册了事件
-     * 具体可查看 {@link Subscribe.hasListener}
-     */
-    hasListener: SubscribeMixinType.hasListener<ModelEventType>;
-    /**
-     * 注册事件
-     * 具体可查看 {@link Subscribe.on}
-     */
-    on: SubscribeMixinType.on<ModelEventType>;
-    /**
-     * 注册事件(是否只执行一次)
-     * 具体可查看 {@link Subscribe.once}
-     */
-    once: SubscribeMixinType.once<ModelEventType>;
-    /**
-     * 解除事件
-     * 具体可查看 {@link Subscribe.off}
-     */
-    off: SubscribeMixinType.off<ModelEventType>;
-    /**
-     * 触发事件
-     * 具体可查看 {@link Subscribe.emit}
+     * 当前显示的楼层
      */
-    emit: SubscribeMixinType.emit<ModelEventType>;
+    get shownFloor(): PBMParameters['floorIndex'] | null;
+    set shownFloor(floorIndex: PBMParameters['floorIndex'] | null);
+    get shownfloor(): PBMParameters['floorIndex'] | null;
+    set shownfloor(floorIndex: PBMParameters['floorIndex'] | null);
     /**
-     * 等待事件
-     * 具体可查看 {@link Subscribe.waitUnitl}
+     * 显示某楼层
+     * @example
+     * ```
+     * model.show() //显示全部楼层
+     * model.show(1) //显示第一楼层
+     * ```
      */
-    waitUnitl: SubscribeMixinType.waitUnitl<ModelEventType>;
-    private renderer?;
-    constructor(renderer?: THREE_2.WebGLRenderer);
+    show(floorIndex?: PBMParameters['floorIndex'] | null): void;
     /**
-     * 当前显示的楼层
-     * @deprecated
-     * 请用 shwonFloor 代替
+     * 裁切
      */
-    get shownfloor(): number | null;
-    get empty(): boolean;
+    get clippers(): PBMParameters['clippers'];
+    set clippers(clippers: PBMParameters['clippers']);
     /**
      * 获取模型边界线
      * @param sphere - 获取区域
@@ -1649,23 +1824,13 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
      * @returns 所有模型边界线
      */
     getEdgesBySphere(sphere: THREE_2.Sphere, threshold?: number): THREE_2.Line3[];
-    /**
-     * 显示某楼层
-     * @example
-     * ```
-     * model.show() //显示全部楼层
-     * model.show(1) //显示第一楼层
-     * model.show(1, 0) //显示第一楼层, 并且其他楼层透明度为 0
-     * ```
-     */
-    show(floorIndex?: number | null): void;
     /**
      * 计算模型射线碰撞检测
      * @param raycaster - THREE 射线对象
      * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
      * @returns 返回碰撞
      */
-    intersectRaycaster(raycaster: THREE_2.Raycaster, floors?: number | number[]): Intersection[];
+    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
     /**
      * 加载模型
      * @param work - work 的
@@ -1675,8 +1840,8 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
         networkSubscribe?: NetworkSubscribe;
         requestProxy?: (url: string) => string | Promise<string>;
         textureOptions?: TextureOptions;
-    }): Promise<Tile3DModel | null>;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
+    }): Promise<void>;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
     /**
      * 析构函数
      * @description
@@ -1688,40 +1853,34 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
 export declare interface ModelControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
 }
 
-/**
- * Five 模型事件列表
- * @description
- * 可以通过 `five.model.on(METHOD_NAME, METHOD)` 调用
- */
-export declare interface ModelEventCallback extends ModelEventType {
+export declare interface ModelEvent extends BaseEvent {
+    model: Model;
+    work: Work;
+    error: Error | null;
 }
 
-/**
- * 模型事件列表
- * @description
- * 具体事件列表 请查看 {@link ModelEventCallback}
- */
-export declare type ModelEventType = {
-    /** 模型加载完成 */
-    loaded(): void;
-    /** 模型细化 */
-    refined(): void;
-    /**
-     * 显示楼层改变
-     * @param shownFloor - 显示的楼层
-     */
-    shownFloorChange(shownFloor: number | null, totalFloorLength: number): void;
-    /**
-     * 内部错误
-     * @param error - 错误对象
-     */
-    error(error: Error): void;
-};
-
 export declare interface ModelLodOptions {
     maxDepth?: number;
 }
 
+export declare type ModelMaterialValues = Pick<PBMParameters, 'pano0' | 'pano1' | 'modelAlpha' | 'progress' | 'useBlackTransition' | 'opacity' | 'constantColor' | 'useEDL' | 'useHQWeight' | 'useHQDepth' | 'pointShape' | 'pointColorType' | 'pointSizeType' | 'pointSize' | 'pointMinSize' | 'pointMaxSize' | 'pointSizeAdaptiveScale' | 'gradientTexture'>;
+
+export declare type Models = Model[] & {
+    needsRender: boolean;
+    bounding: THREE_2.Box3;
+    loaded: boolean;
+    refined: boolean;
+    materialVersion: string;
+    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    setMaterial(values: Partial<ModelMaterialValues>): void;
+    getMaterial(): ModelMaterialValues;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
+};
+
+export declare interface ModelsEvent extends BaseEvent {
+    models: Models;
+}
+
 export declare interface MotionKeyframe<K extends string> {
     progress: number;
     value: MotionValue<K>;
@@ -1733,7 +1892,7 @@ export declare type MotionValue<K extends string> = Record<K, number>;
 /**
  * 点位移动参数
  */
-export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
+export declare interface MovePanoOptions extends Partial<Omit<State, "offset" | 'distance' | 'mode'>> {
     /** 是否通过初始化参数限制 fov, latitude */
     limit?: boolean;
     /**
@@ -1756,9 +1915,9 @@ export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
     /** 运动曲线函数 */
     easing?: (k: number) => number;
     /** 运动开始回调 */
-    moveStartCallback?: (panoId: WorkPanoId, toPose: Pose) => void;
+    moveStartCallback?: (toState: State) => void;
     /** 运动结束回调 */
-    moveEndCallback?: (panoId: WorkPanoId, pose: Pose) => void;
+    moveEndCallback?: (state: State) => void;
     /**
      * 运动被取消回调
      * @description
@@ -1793,6 +1952,13 @@ export declare interface NetworkOptions {
     allowHosts?: string[];
 }
 
+export declare interface NetworkResourceEvent extends BaseEvent {
+    source: string;
+    requestType: NetworkType;
+    requestState: NetworkState;
+    detail: string;
+}
+
 export declare type NetworkResponse<T = any, E extends NetWorkMeta | NetWorkMeta[] = NetWorkMeta> = {
     body: T;
     meta: E;
@@ -1807,6 +1973,15 @@ export declare class NetworkSubscribe extends Subscribe<{
 
 export declare type NetworkType = "XMLHttpRequest" | "Script" | "Image" | "Link";
 
+export declare interface ObjectEvent extends BaseEvent {
+    object: THREE_2.Object3D;
+}
+
+export declare type Pano = {
+    workCode: string;
+    panoIndex: number;
+};
+
 export declare class PanoCircleMesh extends THREE_2.Object3D implements PanoCircleMeshInterface {
     needsRender: boolean;
     private currentStartTime;
@@ -1943,6 +2118,19 @@ export declare interface PanoCircleMeshSolidOptions {
     color?: number;
 }
 
+export declare function panoEqual(a: Pano, b: Pano): boolean;
+
+export declare interface PanoEvent extends StateEvent {
+    prevPano: Pano;
+    progress: number;
+    options: MovePanoOptions;
+    error: Error | null;
+}
+
+export declare type PanoId = `${Pano['workCode']}[${number}]`;
+
+export declare function panoParse(panoId: PanoId): Pano;
+
 export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
     /** 最远可移动观察点距离 */
     maxAccessibleDistance?: number;
@@ -1954,7 +2142,7 @@ export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeCo
      */
     panoTapTriggerRadius?: number;
     /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: (panoId: WorkPanoId) => PanoCircleMeshInterface;
+    panoCircleMeshCreator?: (pano: Pano) => PanoCircleMeshInterface;
     /**
      * 全景瓦片登记
      * @param fov - 当前 fov
@@ -1989,6 +2177,15 @@ export declare interface PanoramaLikeControllerCustomInitArgs {
     intersectMeshCreator?: () => IntersectMeshInterface;
 }
 
+export declare function panoStringify(pano: Pano): PanoId;
+
+export declare interface PanoTextureEvent extends BaseEvent {
+    pano: Pano;
+    progress: number;
+    meta: NetWorkMeta[] | null;
+    error: Error | null;
+}
+
 /**
  * 解析 Work 数据
  * @param obj - work 数据，从如数开发者平台获取
@@ -1998,6 +2195,8 @@ export declare interface PanoramaLikeControllerCustomInitArgs {
 export declare function parseWork(obj: Work | LooseWork | string | any, options?: ParseWorkOptions): Work;
 
 export declare type ParseWorkOptions = {
+    /** 重置 WorkCode */
+    workCode?: string | ((input: any) => string);
     /** 重写资源前缀 */
     baseURL?: string;
     /** 资源地址使用短地址 */
@@ -2035,9 +2234,7 @@ export declare class PBMContainer extends THREE_2.Group {
     setMaterial(parameters: Partial<PBMParameters>): void;
     update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
     /** 析构材质 */
-    disposeMaterial(): void;
-    /** 析构模型网格 */
-    disposeGeometry(): void;
+    dispose(): void;
 }
 
 /** PBM 模型组 */
@@ -2088,6 +2285,10 @@ export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements P
     clippers: ClipperParameter[] | null;
     /** edl*/
     useEDL: boolean;
+    /** hq*/
+    useHQWeight: boolean;
+    /** HQDepthMask*/
+    useHQDepth: boolean;
     /** 点云着色方式*/
     pointColorType: PBMPointColorType;
     /** 点云大小绘制方式*/
@@ -2139,6 +2340,10 @@ export declare interface PBMParameters {
     constantColor: THREE_2.Vector3 | null;
     /** 是否使用EDL*/
     useEDL: boolean;
+    /** 是否使用HQ*/
+    useHQWeight: boolean;
+    /** 是否使用HQ_DEPTH_MASK*/
+    useHQDepth: boolean;
     /** 点云形状*/
     pointShape: PBMPointShapeType;
     /** 点云着色方式*/
@@ -2189,7 +2394,9 @@ export declare interface Pose {
     distance: number;
 }
 
-export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["cameraDirectionUpdate", "cameraUpdate", "cameraPositionUpdate", "panoSelected", "moveToPano", "moveToPanoCanceled", "panoWillArrive", "movingToPano", "panoArrived", "panoWillLoad", "panoLoaded", "panoLoadError", "initAnimationEnded", "initAnimationWillStart", "wantsGesture", "gesture", "wantsTapGesture", "tapGesture", "wantsPressGesture", "pressGesture", "wantsPanGesture", "wantsInteriaPan", "panGesture", "interiaPan", "wantsPinchGesture", "pinchGesture", "wantsMouseWheel", "mouseWheel", "wantsShowIntersectionOnModel", "intersectionOnModelUpdate", "intersectionHidden", "textureStartLoad", "textureLoading", "textureAbort", "textureLoaded", "textureError", "webXRSessionStart", "webXRSessionEnd", "webXRControllerEvent"];
+export declare type PostProcessingType = 'edl' | 'hq' | 'luminance' | null;
+
+export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["gesture.pan", "gesture.tap", "gesture.press", "gesture.pinch", "gesture.mousewheel", "gesture.mousemove", "gesture.momentum", "initAnimation.start", "initAnimation.end", "camera.update", "intersect.update", "pano.select", "pano.moveTo", "pano.moving", "pano.arrived", "pano.cancel", "pano.error", "pano.texture.load", "pano.texture.progress", "pano.texture.success", "pano.texture.error", "pano.texture.abort", "xr.session.start", "xr.session.end", "xr.gesture.tap", "xr.gesture.press", "xr.gesture.buttonUp", "xr.gesture.buttonDown"];
 
 export declare class RegionBoundingVolume implements BoundingVolume {
     type: "regin";
@@ -2218,6 +2425,23 @@ export declare type RegionBoundingVolumeJson = {
     region: number[];
 };
 
+export declare interface RenderEvent extends BaseEvent {
+    needsRender: boolean;
+    info: null | {
+        memory: {
+            geometries: number;
+            textures: number;
+        };
+        render: {
+            calls: number;
+            frame: number;
+            lines: number;
+            points: number;
+            triangles: number;
+        };
+    };
+}
+
 export declare type RequestResult = null | {
     done: () => void;
 };
@@ -2318,10 +2542,15 @@ export declare type SphereBoundingVolumeJson = {
 export declare interface State extends Pose {
     /** 模态 */
     mode: Mode;
+    /** workCode */
+    workCode: string;
     /** 观察点序号 */
     panoIndex: number;
-    /** 观察点id */
-    panoId: string;
+}
+
+export declare interface StateEvent extends BaseEvent {
+    state: State;
+    userAction: boolean;
 }
 
 /**
@@ -2528,7 +2757,7 @@ export declare class Tile {
     loadContent(): Promise<boolean>;
     unloadContent(): boolean;
     getScreenSpaceError(frameState: TilesetFrameState, distanceToCamera: number, useParentGeometricError: boolean): number;
-    private getPriority;
+    getPriority(): number;
 }
 
 export declare class Tile3DModel extends THREE_2.Object3D {
@@ -2542,11 +2771,12 @@ export declare class Tile3DModel extends THREE_2.Object3D {
     boundingBox: THREE_2.Box3;
     needsRefined: boolean;
     refined: boolean;
+    loaded: boolean;
     disposed: boolean;
     needsRender: boolean;
     lastRefineTime: number;
-    private nodeGroup;
-    private debugBoundingGroup;
+    nodeGroup: THREE_2.Group;
+    debugBoundingGroup: THREE_2.Group;
     private nodes;
     private debugBoundings;
     private unloadTileQueue;
@@ -2577,6 +2807,7 @@ export declare interface Tile3DModelLoaderOptions {
     allowHosts?: string[];
     requestProxy?: (url: string) => string | Promise<string>;
     networkSubscribe?: NetworkSubscribe;
+    onError?: (error: Error) => void;
 }
 
 export declare type TileContentData = {
@@ -2744,7 +2975,7 @@ export declare interface TilesetHeader {
 export declare interface TilesetOptions {
     onTileLoad: (tile: Tile) => any;
     onTileUnload: (tile: Tile) => any;
-    onTileError: (tile: Tile, message: string) => any;
+    onTileError: (tile: Tile, error: Error) => any;
     contentLoader: (tile: Tile) => Promise<boolean>;
     allowHosts?: string[];
     requestProxy?: (url: string) => string | Promise<string>;
@@ -2798,26 +3029,36 @@ export declare enum VolumePlaneIntersect {
 export declare interface VRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
 }
 
-export declare type WebXRControllerKey = 'A' | 'B' | 'X' | 'Y' | 'RightTrigger' | 'RightPinch' | 'LeftTrigger' | 'LeftPinch' | 'LeftAxesLeft' | 'LeftAxesRight' | 'LeftAxesUp' | 'LeftAxesDown' | 'RightAxesLeft' | 'RightAxesRight' | 'RightAxesUp' | 'RightAxesDown';
+export declare interface WebXRAxesParams {
+    raycaster: {
+        leftRay: THREE_2.Raycaster;
+        rightRay: THREE_2.Raycaster;
+    };
+    axesState: {
+        up: number;
+        down: number;
+        left: number;
+        right: number;
+    };
+    deltaTime: number;
+}
+
+export declare type WebXRControllerKey = XRGestureEvent['buttons'];
 
 export declare interface WebXRControllerParams {
-    raycaster: THREE_2.Raycaster[];
+    raycaster: {
+        leftRay: THREE_2.Raycaster;
+        rightRay: THREE_2.Raycaster;
+    };
 }
 
-export declare type WebXRControllerType = 'tap' | 'press' | 'axes';
-
-export declare type WebXREventTypes = {
-    /** WebXR模式开始，session完成坐标系设置*/
-    webXRSessionStart(): void;
-    /** WebXR模式结束，销毁session*/
-    webXRSessionEnd(): void;
-};
+export declare type WebXRControllerType = 'tap' | 'press' | 'axes' | 'buttonUp' | 'buttonDown';
 
 export declare class Work {
     /** 名称 */
     name: string;
     /** 编号 */
-    workCode: WorkCode;
+    workCode: string;
     /** 允许访问的安全域名 */
     allowHosts: string[];
     /** 过期时间 */
@@ -2848,8 +3089,6 @@ export declare class Work {
     toJSON(): any;
 }
 
-export declare type WorkCode = string;
-
 export declare interface WorkCubeImage {
     /** 全景图 up */
     up: string;
@@ -2877,10 +3116,11 @@ export declare interface WorkImage extends WorkCubeImage {
 
 /** 初始化位姿参数 */
 export declare interface WorkInitial {
+    work: Work;
     /** 模态 */
     mode?: Mode;
     /** 点位序号 */
-    panoId?: string;
+    panoIndex?: number;
     /** 相机水平角 */
     longitude?: number;
     /** 相机俯仰角 */
@@ -2903,7 +3143,13 @@ export declare interface WorkModel {
     textures?: string[];
     /** 模型贴图文件地址的父目录 */
     textureBase?: string;
-    tileset?: string;
+    /** 3d tile */
+    layers: {
+        type: 'point_cloud' | 'mesh';
+        name: string;
+        upAxis: string;
+        tileset: string;
+    }[];
 }
 
 /** 每个点位的数据 */
@@ -2912,8 +3158,12 @@ export declare interface WorkObserver {
     work: Work;
     /** 序号 */
     index: number;
+    /** 序号 */
+    panoIndex: number;
+    /** 点位序号 */
+    panoId: PanoId;
     /** 点位序号 */
-    panoId: WorkPanoId;
+    pano: Pano;
     /** 点位所在楼层 */
     floorIndex: number;
     /** 点位 derived_id */
@@ -2927,9 +3177,13 @@ export declare interface WorkObserver {
     /** 点位视频 */
     video?: WorkVideo;
     /** 可以看到的相关点位序号 */
-    visibleIds: string[];
+    visibleNodes: number[];
+    /** 可以看到的相关点位序号 */
+    visibleIds: PanoId[];
     /** 可以连通的相关点位序号 */
-    accessibleIds: string[];
+    accessibleNodes: number[];
+    /** 可以看到的相关点位序号 */
+    accessibleIds: PanoId[];
     /** 点位和模型的地面坐标 */
     standingPosition: THREE_2.Vector3;
     /** 点位和模型的观察点坐标 */
@@ -2955,16 +3209,25 @@ export declare interface WorkOptions {
     modelMaxScreenSpaceError?: number;
 }
 
-export declare type WorkPanoId = string;
+export declare interface WorkResolvedObserver extends WorkObserver {
+    isResolved: true;
+}
 
 export declare type Works = ReadonlyArray<Work> & {
-    resolvedObservers: WorkObserver[];
+    resolvedObservers: WorkResolvedObserver[];
     initial: WorkInitial;
-    getWork(workCode: WorkCode): Work | undefined;
-    getResolvedObserver(panoId: WorkPanoId): WorkObserver | undefined;
+    getWork(workCode: string): Work | undefined;
+    getResolvedObserver(pano: PanoId | Pano | number): WorkResolvedObserver | undefined;
     update(): void;
 };
 
+export declare interface WorksEvent extends BaseEvent {
+    input: any;
+    works: Works;
+    state: Partial<State>;
+    userAction: boolean;
+}
+
 export declare interface WorkTile {
     level: number;
     size: number;
@@ -2990,7 +3253,44 @@ export declare class XRButton {
     static createButton(onClickHook: () => void): HTMLAnchorElement | HTMLButtonElement;
 }
 
+export declare interface XRControllerEvent extends BaseEvent {
+    controller: {
+        type: 'left' | 'right';
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
+        };
+        raycaster: {
+            leftRay: THREE_2.Raycaster;
+            rightRay: THREE_2.Raycaster;
+        };
+        deltaTime: number;
+    };
+}
+
+export declare interface XRGestureEvent extends BaseEvent {
+    session: XRSession | null;
+    buttons: 'A' | 'B' | 'X' | 'Y' | 'RightTrigger' | 'RightPinch' | 'LeftTrigger' | 'LeftPinch' | 'LeftAxesLeft' | 'LeftAxesRight' | 'LeftAxesUp' | 'LeftAxesDown' | 'RightAxesLeft' | 'RightAxesRight' | 'RightAxesUp' | 'RightAxesDown';
+    machineType: 'Pico' | 'Oculus';
+    isFirst: boolean;
+    isFinal: boolean;
+    controllers: {
+        raycaster: {
+            leftRay: THREE_2.Raycaster;
+            rightRay: THREE_2.Raycaster;
+        };
+    };
+}
+
 export declare interface XRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
 }
 
+declare interface XRSessionEvent_2 extends BaseEvent {
+    session: XRSession | null;
+    machineType: 'Pico' | 'Oculus';
+}
+export { XRSessionEvent_2 as XRSessionEvent }
+
 export { }