@realsee/five 6.0.0-alpha.1 → 6.0.0-alpha.100

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 {
@@ -11,6 +13,15 @@ export declare interface AddableObject extends THREE_2.Object3D {
     setTime?(time: number): void;
 }
 
+export declare interface AjaxOptions<T extends AjaxResponseType = AjaxResponseType> extends NetworkOptions {
+    /** 数据返回类型 */
+    responseType?: T;
+}
+
+export declare type AjaxResponseType = "arraybuffer" | "blob" | "text";
+
+export declare type AjaxResponseTypeMapping<K extends AjaxResponseType> = K extends "arraybuffer" ? ArrayBuffer : K extends "blob" ? Blob : K extends "text" ? string : never;
+
 export declare interface AnimationFrame {
     callback: (time: number, deltaTime: number, ...args: any[]) => void;
     once: boolean;
@@ -46,16 +57,24 @@ 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;
     getBoundingBox(target: THREE_2.Box3): THREE_2.Box3;
     toGeometry(): THREE_2.BufferGeometry;
     getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
-    distanceSquaredTo(point: THREE_2.Vector3): number;
-    distanceTo(point: THREE_2.Vector3): number;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
-    intersectRay(ray: THREE_2.Ray): boolean;
+    intersectRay(ray: THREE_2.Ray, far?: number): boolean;
     clone(): BoundingVolume;
     copy(boundingVolume: this): this;
     fromJson(json: any): this;
@@ -76,75 +95,19 @@ export declare class BoxBoundingVolume implements BoundingVolume {
     clone(): BoxBoundingVolume;
     applyMatrix4(matrix: THREE_2.Matrix4): this;
     getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
-    distanceSquaredTo(point: THREE_2.Vector3): number;
-    distanceTo(point: THREE_2.Vector3): number;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     getBoundingBox(target: THREE_2.Box3): THREE_2.Box3;
     toGeometry(): THREE_2.BufferGeometry;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
-    intersectRay(ray: THREE_2.Ray): boolean;
+    intersectRay(ray: THREE_2.Ray, far?: number): boolean;
 }
 
 export declare type BoxBoundingVolumeJson = {
     box: number[];
 };
 
-export declare class BVH {
-    trianglesArray?: Float32Array;
-    offsetArray?: Uint32Array;
-    rootNode?: BVHNode;
-    create(trianglesArray: Float32Array): this;
-    splitNode(maxTrianglesPerNode: number): this;
-    /**
-     * 计算射线与三角形的碰撞
-     * @param rayOrigin - 射线的原点坐标
-     * @param rayDirection - 设想的方向向量
-     * @param backfaceCulling - 是否背面剔除
-     * @return 碰撞焦点数组
-     */
-    intersectRay(rayOrigin: BVHVector3, rayDirection: BVHVector3, backfaceCulling: boolean): BVHIntersect[];
-    trianglesInSphere(center: BVHVector3, radius: number): Float32Array;
-    dispose(): void;
-}
-
-export declare class BVHIntersect {
-    triangle: [BVHVector3, BVHVector3, BVHVector3];
-    intersectionPoint: BVHVector3;
-    constructor(triangle: [BVHVector3, BVHVector3, BVHVector3], intersectionPoint: BVHVector3);
-}
-
-/**
- * A node in the BVH structure
- * @param extents - the min coords of this node's bounding box
- * @param startIndex - an index in the bbox array, where the first element of this node is located
- * @param endIndex - an index in the bbox array, where the last of this node is located, plus 1 (meaning that its non-inclusive).
- * @param level - distance of this node from the root for the bvh tree. root node has level=0, its children have level=1 etc.
- */
-export declare class BVHNode {
-    extents: ArrayLike<number>;
-    startIndex: number;
-    endIndex: number;
-    node0?: BVHNode;
-    node1?: BVHNode;
-    constructor(extents: ArrayLike<number>, startIndex: number, endIndex: number);
-}
-
-export declare class BVHVector3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x: number, y: number, z: number);
-    copy(v: BVHVector3): this;
-    set(x: number, y: number, z: number): this;
-    fromArray(array: number[], firstElementPos?: number): this;
-    add(v: BVHVector3): this;
-    multiplyScalar(scalar: number): this;
-    subVectors(a: BVHVector3, b: BVHVector3): this;
-    dot(v: BVHVector3): number;
-    cross(v: BVHVector3): this;
-    crossVectors(a: BVHVector3, b: BVHVector3): this;
-    clone(): BVHVector3;
-}
-
 /** Five 相机 */
 export declare class Camera extends THREE_2.Camera {
     fov: number;
@@ -152,14 +115,17 @@ export declare class Camera extends THREE_2.Camera {
     near: number;
     far: number;
     perspToOrtho: THREE_2.Vector2;
-    orthoDistance: number;
+    resolution: THREE_2.Vector2;
+    pixelRatio: number;
     /** 相机姿态 */
     pose: CameraPose;
     private perspectiveCamera;
     private orthographicCamera;
     needsRender: boolean;
+    refineModel: boolean;
     private lastValues;
-    constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE_2.Vector2, orthoDistance?: number);
+    constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE_2.Vector2, resolution?: THREE_2.Vector2, pixelRatio?: number);
+    get orthoDistance(): number;
     get zoom(): number;
     get top(): number;
     get bottom(): number;
@@ -194,17 +160,6 @@ export declare interface CameraPose {
     offset: THREE_2.Vector3;
 }
 
-export declare class Clipper {
-    numPlanes: number;
-    clipperPlanes: Float32Array | null;
-    clipperFloors: number[] | null;
-    private static sharedInstance?;
-    static get shared(): Clipper;
-    constructor();
-    update(clipperParameters: ClipperParameter[], camera: THREE_2.Camera): void;
-    private projectPlanes;
-}
-
 export declare interface ClipperParameter {
     clippingBoxMatrix: THREE_2.Matrix4;
     floorIndex?: number;
@@ -216,1218 +171,1456 @@ export declare type ControllerCustomInitTypes = {
     Panorama: PanoramaControllerCustomInitArgs;
     VRPanorama: VRPanoramaControllerCustomInitArgs;
     Model: ModelControllerCustomInitArgs;
-    DepthPanorama: DepthPanoramaControllerCustomInitArgs;
     Mapview: MapviewControllerCustomInitArgs;
     XRPanorama: XRPanoramaControllerCustomInitArgs;
 };
 
 export declare type ControllerEventTypes = {
+    /** 手势 滑动屏幕 */
+    "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 {
+    static get MASK_OUTSIDE(): number;
+    static get MASK_INSIDE(): number;
+    static get MASK_INDETERMINATE(): number;
+    planes: THREE_2.Plane[];
+    constructor(planes?: THREE_2.Plane[]);
+    setFromFrustum(frustum: THREE_2.Frustum): this;
+    setFromCamera(camera: THREE_2.Camera): this;
+    applyMatrix4(matrix: THREE_2.Matrix4): void;
+    copy(cullingVolume: CullingVolume): this;
+    clone(): CullingVolume;
+    computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
+    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
+}
+
+/**
+ * URL 地址的转换
+ * @param source - url 原地址
+ * @param options - url 转换参数
+ * @returns url 转换结果
+ */
+export declare function defaultImageURLTransform(source: string, options: ImageURLOptions): string;
+
+export declare const defaultPbmParameters: PBMParameters;
+
+/**
+ * Five 事件列表
+ * @description
+ * 可以通过 `five.on(METHOD_NAME, METHOD)` 调用
+ */
+export declare interface EventCallback extends EventTypes {
+}
+
+/**
+ * Five 事件列表
+ * @description
+ * 具体事件列表 请查看 {@link EventCallback}
+ */
+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;
+    /** 模型细化完成 */
+    "models.refined"(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;
+};
+
+export declare class Fetcher {
+    private options;
+    constructor(options?: NetworkOptions);
+    ajax<T extends AjaxResponseType = "text">(source: string, options?: AjaxOptions<T>, onLoad?: NetworkSuccessCallback<AjaxResponseTypeMapping<T>>, onError?: NetworkErrorCallback, onProgress?: NetworkProgressCallback): Promise<NetworkResponse<AjaxResponseTypeMapping<T>>>;
+    loadImage<T extends HTMLImageElement = HTMLImageElement>(source: string, options?: NetworkOptions, onLoad?: NetworkSuccessCallback, onError?: NetworkErrorCallback, onProgress?: NetworkProgressCallback, target?: T): Promise<NetworkResponse<T>>;
+    preload(source: string, options?: NetworkOptions): Promise<void>;
+}
+
+/**
+ * 如视 VR Web展示器
+ *
+ * @example
+ * ```
+ * // 初始化构造函数
+ * const five = new Five();
+ * // 将绘制区域添加到页面上
+ * five.appendTo(document.body);
+ * // 加载 Work 数据
+ * five.load({...});
+ * ```
+ */
+export declare class Five extends Subscribe<EventTypes> {
+    static get version(): string;
+    static get dracoPath(): string;
+    static set dracoPath(path: string);
+    static get ktx2Path(): string;
+    static set ktx2Path(path: string);
     /**
-     * 模态间切换动画开始
-     * @param panoId - 当前点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
-     */
-    initAnimationWillStart(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
-    /**
-     * 模态间切换动画结束
-     * @param panoId - 当前点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
+     * Five 的显示模式，可以通过 `five.changeMode` `five.setState` 来切换
+     * @description
+     * ```text
+     * Panorama 全景图游走模式
+     * Model 模型游走模式
+     * Floorplan 模型查看模式
+     * Topview 户型图模式
+     * VRPanorama VR眼镜模式
+     * XRPanorama VR硬件模式
+     * ```
      */
-    initAnimationEnded(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
+    static Mode: Mirror<Mode>;
     /**
-     * 意图要变化相机的可视角度 可以通过 `return false` 阻止
      * @deprecated
-     * 建议通过 初始化设置的 `defaultFov`, `maxFov`, `minFov` 来限制
-     * @param fov - 意图要变化相机的可视角度
-     * @returns 可以通过 `return false` 阻止
+     * 请使用 `import { Line } from "@realsee/five/line"` 代替;
      */
-    wantsChangeCameraFov(fov: number): void | false;
+    static Line: any;
     /**
-     * 相机姿态变化
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
+     * 自动播放状态是否暂停
+     * @description
+     * 可以通过 `five.play` `five.pause` 方法播放或暂停
      */
-    cameraUpdate(pose: Pose, userAction: boolean): void;
+    paused: boolean;
+    /** 当前点位序号 */
+    pano: Pano;
+    /** 当前展示的模式 */
+    currentMode: Mode;
+    /** 内部使用的 `THREE.Scene` */
+    scene: Scene;
+    /** 供外部放置需要在xr场景下产生遮挡的物体们*/
+    xrCustomObjectsScene: THREE_2.Scene;
+    /** 内部使用的 `Camera` */
+    camera: Camera;
     /**
-     * 相机姿态中可视角度变化
-     * @param fov - 相机的可视角度
-     * @param userAction - 是否用户触发
+     * 当前设置的 `scissor`
+     * @description
+     * 可通过初始化，或者 setScissor 方式设置
+     * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+     * @example
+     * ```
+     * scissor: { left: 0.75, bottom: 0, width: 0.25, height: 1 }
+     * ```
      */
-    cameraFovUpdate(fov: Pose["fov"], userAction: boolean): void;
+    scissor: Scissor;
     /**
-     * 相机姿态中相机位置变化
-     * @param offset - 相机位置
-     * @param userAction - 是否用户触发
+     * 当前使用的 THREE.WebGLRenderer。
+     * @description
+     * 如果初始化时传入了 `renderer` 则直接时该值
+     * 否则会通过 `preserveDrawingBuffer` `backgroundColor` `backgroundAlpha` `antialias` 创建一个 `THREE.WebGLRenderer`
      */
-    cameraPositionUpdate(offset: Pose["offset"], userAction: boolean): void;
+    renderer?: THREE_2.WebGLRenderer;
+    /** 当前加载的模型 */
+    models: Models;
+    private lastModels;
+    private lastWorks?;
     /**
-     * 相机姿态中相机方向变化
-     * @param coordinates - 相机姿态的俯仰角和偏航角
-     * @param userAction - 是否用户触发
+     * 是否需要渲染
+     * @description
+     * 如果初始化设置了 `onlyRenderIfNeeds: true`, 则会激活按需渲染
+     * 可以通过设置 `five.needsRender = true` 来告知，five 会在下一帧渲染画面。
      */
-    cameraDirectionUpdate(coordinates: Pick<Pose, "longitude" | "latitude">, userAction: boolean): void;
+    needsRender: boolean;
     /**
-     * 观察点位被选择
-     * @param panoId - 选择的点位
+     * 全景图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的全景图片在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
      */
-    panoSelected(panoId: WorkPanoId | null): void;
+    imageOptions: ImageOptions;
     /**
-     * 意图要移动到某个点位 可以通过 `return false` 阻止
-     * @param panoId - 图要移动到的点位
-     * @param options - 移动参数
-     * @param userAction - 是否用户触发
-     * @returns 可以通过 `return false` 阻止
+     * 模型贴图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
      */
-    wantsMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void | false;
+    textureOptions: TextureOptions;
     /**
-     * 开始加载并移动到某个观察点位
+     * 模型贴图的配置参数
      * @description
-     * 可 panoWillArrive 相比
-     * - moveToPano 在加载全景图资源前触发
-     * - panoWillArrive 在加载全景图资源后触发
-     * @param panoId - 移动到的点位
-     * @param userAction - 是否用户触发
+     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
      */
-    moveToPano(panoId: WorkPanoId, userAction: boolean): void;
+    videoTexture: THREE_2.VideoTexture;
     /**
-     * 开始加载某个观察点的全景资源
-     * @param panoId - 移动到的点位
+     * 当前状态
+     * @description
+     * ```text
+     * five 设置了以下状态
+     *
+     * - mode: Mode
+     * - panoIndex: number
+     * - longitude: number
+     * - latitude: number
+     * - fov: number
+     * - offset: THREE.Vector3
+     *
+     * 可以通过 five.state 和 five.setState 来获取和设置。
+     * 通过 state 设置后，five 会通过合适的动画运动来达到设置的位置。
+     * 来迎合一些通过数据驱动的场景。
+     * ```
      */
-    panoWillLoad(panoId: WorkPanoId): void;
+    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>;
+    };
+    ident: string;
+    /** 包围盒子 */
+    private boundingMesh;
+    private stopAnimationLoop?;
+    private fps;
+    private modelGroup;
+    private helperGroup;
+    private modeChangeDuration;
+    private enableWheel;
+    private onlyRenderIfNeeds;
+    private poweredByRealsee;
+    private controller?;
+    private destroyed;
+    private stateSynced;
+    private controllerInits;
+    private extraElements;
+    private getPixelsRenderTarget;
+    private readyCallbacks;
+    private syncingState;
     /**
-     * 某个观察点的全景资源加载完成
-     * @param panoId - 对应的点位
+     * 是否开启 IOS EDR 模式
+     * 需要客户端配合
+     * 并且开启 five.enablepostProcessing = true
      */
-    panoLoaded(panoId: WorkPanoId): void;
+    private _enableIOSEDR;
+    private lastLoadWorkTask;
+    private requestProxy;
+    private networkSubscribe;
+    private screenBuffers?;
+    private analysis?;
+    private renderSwitch01;
     /**
-     * 某个观察点的全景资源加载失败
-     * @param error - 错误对象
-     * @param panoId - 对应的点位
+     * gpu_picking
      */
-    panoLoadError(error: Error, panoId: WorkPanoId): void;
+    private gpuPickingRenderTarget;
+    private meshReplaceMaterialMap;
+    private meshOriginMaterialMap;
+    private copyEffect;
+    constructor(initArgs?: FiveInitArgs);
+    get panoIndex(): number;
     /**
-     * 移动到某个观察点位被取消
-     * @description
-     * 这个有一些情况会导致
-     * - 移动过程中切换模态
-     * - 移动过程中 five 被析构
-     * - 移动过程点击切换到另一个点位
-     * @param panoId - 对应的点位
+     * GPU Picking 获取选中的 mesh
+     * @param x - 屏幕坐标 x
+     * @param y - 屏幕坐标 y
+     * @param colorMap - 需要选取的 mesh 的颜色与 uuid 的映射
+     * @param color - 指定的模型颜色
+     * @returns 选中 mesh 的 uuid
      */
-    moveToPanoCanceled(panoId: WorkPanoId): void;
+    getGPUPicking(x: number, y: number, colorMap: {
+        [key: string]: THREE_2.Color;
+    }, pixelRatio?: number, color?: THREE_2.Vector3): string | false;
     /**
-     * 开始移动到某个观察点位
+     * 析构 five 对象。
      * @description
-     * 和 moveToPano 相比
-     * - moveToPano 在加载全景图资源前触发
-     * - panoWillArrive 在加载全景图资源后触发
-     * @param panoId - 移动到点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
+     * 一旦调用了析构方法，则不能再使用当前 five 对象了。
+     * 你可以新建一个新的。
      */
-    panoWillArrive(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
+    dispose(): void;
     /**
-     * 移动到某个观察点位
-     * @param panoIndex - 移动到点位
-     * @param pose - 相机姿态
-     * @param userAction - 是否用户触发
+     * 设置 `scissor`
+     * @param scissor - 指定区域
+     * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+     * 请确保在 five 初始化时传入 `renderer` 对象
+     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+     * @example
+     * ```
+     * five.setScissor({ left: 0.75, bottom: 0, width: 0.25, height: 1 })
+     * ```
      */
-    panoArrived(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
+    setScissor(scissor: Scissor): void;
     /**
-     * 移动中， 会告知移动状态（耗时百分比）
-     * @param panoId - 将要移动到的点位下标
-     * @param prevPanoId - 上一个点位下标
-     * @param progress - 整个过程经度 [0-1]
+     * 帮助元素显示/隐藏
      */
-    movingToPano(panoId: WorkPanoId, prevPanoId: WorkPanoId, progress: number): void;
+    get helperVisible(): boolean;
+    set helperVisible(visible: boolean);
     /**
-     * 意图要触发手势， 可以通过 `return false` 阻止
-     * @param type - 手势类型
-     * @param pointers - 手指位置
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 是否开启 IOS EDR 模式
+     * 需要客户端配合
+     * 并且开启 five.enablepostProcessing = true
      */
-    wantsGesture(type: GestureTypes, pointers: {
-        x: number;
-        y: number;
-        delta?: number;
-    }[], final: boolean): void | false;
+    get enableIOSEDR(): boolean;
+    set enableIOSEDR(enable: boolean);
     /**
-     * 手势 触发
-     * @param type - 手势类型
-     * @param pointers - 手指位置
-     * @param final - 是否手势结束
+     * 后处理类型
      */
-    gesture(type: GestureTypes, pointers: {
-        x: number;
-        y: number;
-        delta?: number;
-    }[], final: boolean): void;
+    get postProcessingType(): PostProcessingType;
     /**
-     * 意图要触发 pan 手势(滑动屏幕)， 可以通过 `return false` 阻止
-     * @param pose - 意图的相机姿态
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 是否开启EDL模式
      */
-    wantsPanGesture(pose: Pose, final: boolean): void | false;
+    get enableEDL(): boolean;
+    set enableEDL(enable: boolean);
+    get enableHQ(): boolean;
+    set enableHQ(enable: boolean);
     /**
-     * pan 手势(滑动屏幕) 被触发
-     * @param pose - 相机姿态
-     * @param final - 是否手势结束
+     * 是否开启后处理
      */
-    panGesture(pose: Pose, final: boolean): void;
+    get enablePostProcessing(): boolean;
+    set enablePostProcessing(enable: boolean);
+    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "vrPanorama" | "imageOptions" | "textureOptions">, refresh?: boolean): void;
     /**
-     * 意图要触发 pan 手势(滑动屏幕) 的惯性运动, 可以通过 `return false` 阻止
-     * @param pose - 意图的相机姿态
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 将显示区域加载到页面 DOM 中
+     * @description
+     * 如果你是传入的 `renderer`. 则你需要自行来方式显示区域该方法并不生效
+     *
+     * @param element - 加载到页面的 DOM 元素
+     * @param size - 显示区域尺寸 默认铺满这个 DOM 元素
      */
-    wantsInteriaPan(pose: Pose): void | false;
+    appendTo(element: HTMLElement, size?: {
+        width?: number;
+        height?: number;
+    }): void;
     /**
-     * pan 手势(滑动屏幕) 的惯性运动
-     * @param pose - 意图的相机姿态
-     * @param final - 是否手势结束
+     * 设置显示区域尺寸
+     * @description
+     * 如果你是传入的 `renderer`. 则你需要自行来设置显示区域尺寸，该方法并不生效
+     *
+     * @param size - 显示区域尺寸 默认铺满这个 DOM 元素
+     * @param pixelRatio - 像素比 默认继承之前的设置
      */
-    interiaPan(pose: Pose, final: boolean): void;
+    refresh(size?: {
+        width?: number;
+        height?: number;
+    }, pixelRatio?: number): void;
     /**
-     * 意图要触发 tap 手势(点击屏幕)， 可以通过 `return false` 阻止
-     * @param raycaster - 点击对应的三维射线
-     * @param tapPosition - 点击对应的屏幕位置
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 绑定一个额外 DOM 区域，接受触控/鼠标事件
+     * @returns 解除该绑定
      */
-    wantsTapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void | false;
+    addExtraElement(element: HTMLElement): () => void;
     /**
-     * tap 手势(点击屏幕) 被触发
-     * @param raycaster - 点击对应的三维射线
-     * @param tapPosition - 点击对应的屏幕位置
-     * @param final - 是否手势结束
+     * 解除绑定的一个额外 DOM 区域
      */
-    tapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void;
+    removeExtraElement(element: HTMLElement): void;
     /**
-     * 意图要触发 pinch 手势(双指缩放)，可以通过 `return false` 阻止
-     * @param scale - 缩放数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 获取当前相机姿态, 可以使用 getCurrentState 代替
      */
-    wantsPinchGesture(scale: number, nextFov: number, final: boolean): void | false;
+    getPose(): Pose;
+    getSize(target: THREE_2.Vector2): THREE_2.Vector2;
+    getDrawingBufferSize(target: THREE_2.Vector2): THREE_2.Vector2;
     /**
-     * 意图要触发 press 手势(长按屏幕)， 可以通过 `return false` 阻止
-     * @param raycaster - 长按对应的三维射线
-     * @param tapPosition - 长按对应的屏幕位置
-     * @param duration - 长按持续时间
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 移动相机。（不触发点位移动）
+     * @description
+     * 如果动画中途被打断（用户触发行为，或者调用 setState, load, changeMode）的等
+     * 会 Promise.reject。运动完成则 Promise.resolve
+     * @param pose - 相机目标位置
+     * @param duration - 动画触发的时常
+     * @param userAction - 是否用户触发
+     * @returns Promise 是否移动成功
      */
-    wantsPressGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, duration: number, isFinal: boolean): void | false;
+    updateCamera(pose: Partial<Pose>, duration: number, userAction?: boolean): Promise<void>;
     /**
-     * tap 手势(点击屏幕) 被触发
-     * @param raycaster - 点击对应的三维射线
-     * @param tapPosition - 点击对应的屏幕位置
-     * @param duration - 长按持续时间
-     * @param final - 是否手势结束
+     * 通过帧动画移动相机。（不触发点位移动）
+     * @description
+     * 如果动画中途被打断（用户触发行为，或者调用 setState, load, changeMode）的等
+     * 会 Promise.reject。运动完成则 Promise.resolve
+     * @param keyframes - 动画帧
+     * @param duration - 动画触发的时常
+     * @param userAction - 是否用户触发
+     * @returns Promise 是否移动成功
      */
-    pressGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, duration: number, isFinal: boolean): void;
+    updateCameraWithKeyframes(keyframes: {
+        progress: number;
+        value: Pose;
+        key?: string;
+    }[], duration: number, userAction?: boolean): Promise<void>;
     /**
-     * pinch 手势(双指缩放) 被触发
-     * @param scale - 缩放数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
+     * 获取当前相机经纬度
+     * @deprecated 请使用使用 getPose
      */
-    pinchGesture(scale: number, fov: number, final: boolean): void;
+    getLongitudeAndLatitude(): Pick<Pose, "longitude" | "latitude">;
     /**
-     * 意图要触发 鼠标滚轮 可以通过 `return false` 阻止
-     * @param delta - 滚轮数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
-     * @returns 可以通过 `return false` 阻止
+     * 获取当前相机位置
+     * @deprecated 请使用使用 getPose
      */
-    wantsMouseWheel(delta: number, nextFov: number, final: boolean): void | false;
+    getOffset(): Pose["offset"];
     /**
-     * 鼠标滚轮被触发
-     * @param delta - 滚轮数值
-     * @param nextFov - 意图的fov变更
-     * @param final - 是否手势结束
+     * 获取当前相机的姿态（用于内部的 python 脚本截图）
+     * @deprecated 这是用于内部的 python 脚本截图
      */
-    mouseWheel(delta: number, fov: number, final: boolean): void;
+    getCameraLocal(): {
+        theta: number;
+        phi: number;
+        lookAtVector: THREE_2.Vector3;
+    };
+    /** 当前加载的 work 数据 */
+    get works(): Works;
+    get work(): Work | undefined;
+    get model(): Model;
     /**
-     * 鼠标焦点环位置被重新计算
-     * @param intersection - 焦点碰撞结果
-     * @param mesh - 焦点环 mesh
+     * 加载 Work 数据
+     * @param inputWork - Work 数据
+     * @param state - 初始化姿态
+     *  - "inherit" 使用当前姿态
+     *  - "initial" 使用 Work 数据中的 initial 姿态
+     *  - State 自定义姿态
+     * @param options - 切换时间, 切换效果
      */
-    intersectionOnModelUpdate(intersection: Intersection, mesh: IntersectMeshInterface): void;
+    load(inputWork: string | Work | LooseWork | string[] | Work[] | LooseWork[] | LooseWorkWithExtrinsics[] | Promise<Work | LooseWork | Work[] | LooseWork[] | LooseWorkWithExtrinsics[]>, state?: "inherit" | "initial" | Partial<State>, options?: number | FiveLoadOptions, userAction?: boolean): Promise<void>;
+    private load_;
     /**
-     * 意图要展示鼠标焦点环，可以通过 `return false` 阻止
-     * @param intersection - 焦点碰撞结果
-     * @returns 可以通过 `return false` 阻止
+     * 切换模态
+     * @param mode - 切换到的模态
+     * @param state - 切换完成时的姿态
+     * @param options - 模态切换动画用时
+     * @param userAction - 是否时用户动作触发 默认 true
+     * @param force - 必须重新初始化 controller
      */
-    wantsShowIntersectionOnModel(raycaster: THREE_2.Raycaster): void | false;
-    /** 鼠标焦点环被隐藏 */
-    intersectionHidden(): void;
-    /** 意图要退出VR眼镜模式 */
-    vrWantsToExit(): void;
+    changeMode<T extends Mode>(mode: T, state?: Partial<Omit<State, "mode">>, options?: number | {
+        duration?: number;
+        effect?: MovePanoEffect;
+    }, userAction?: boolean, force?: boolean): Promise<void>;
     /**
-     * 观察点的全景资源开始加载
-     * @param panoId - 加载点位
+     * 获取画面中的像素颜色
+     * @param x - 获取像素区域的起始坐标 x
+     * @param y - 获取像素区域的起始坐标 y
+     * @param width - 获取像素区域的宽度
+     * @param height - 获取像素区域的高度
+     * @param pixelRatio - 获取区域的像素比
+     * @returns rgba颜色平铺的 Uint8Array
      */
-    textureStartLoad(panoId: WorkPanoId): void;
+    getPixels(x: number, y: number, width: number, height: number, pixelRatio?: number): Uint8Array;
     /**
-     * 观察点的全景资源加载中，可获取到进度
-     * @param progress - 加载进度 [0-1]
-     * @param panoId - 加载点位下标
+     * 获取显示用的画布（Canvas DOM节点）
      */
-    textureLoading(progress: number, panoId: WorkPanoId): void;
+    getElement(): HTMLCanvasElement | undefined;
     /**
-     * 观察点的全景资源加载被中止
-     * @param panoId - 加载点位
+     * 获取观测点
      */
-    textureAbort(panoId: WorkPanoId): void;
+    get observers(): WorkResolvedObserver[];
     /**
-     * 观察点的全景资源加载失败
-     * @param error - 错误对象
-     * @param panoId - 加载点位
+     * 强制渲染
+     * @description
+     * 调用 `five.render()` 和设置 `five.needsRender = true` 均可在按需渲染时，使得画面渲染一次
+     * 区别在于：
+     * - `five.needsRender = true` 为在下帧渲染画面
+     * - `five.render()` 在当前帧渲染画面
+     * 推荐使用 `five.needsRender = true`, 可以更加流畅。但是如果需要截图等同步操作，可以使用 `five.render()`
+     *
+     * @param callback - 渲染完成回调
      */
-    textureError(error: Error, panoId: WorkPanoId): void;
+    render(callback?: () => void, updateObjectResolution?: boolean): THREE_2.WebGLRenderTarget;
+    updateTime(time: number, deltaTime: number, ...args: any[]): void;
     /**
-     * 观察点的全景资源加载完成
-     * @param panoId - 加载点位
+     * 暂停自动播放
      */
-    textureLoaded(panoId: WorkPanoId, meta: (NetWorkMeta | null)[]): void;
+    pause(): void;
+    play(): void;
     /**
-     * 抛出错误
-     * @param error - 抛出错误
+     * 转化到 Panorama 模态，并移动到对应序号的观察点。
+     * @param panoIndex - 观察点序号
+     * @param options - 移动点位参数
+     * @param userAction - 是否用户触犯
      */
-    error(error: Error): void;
+    moveToPano(pano: Pano | PanoId | number, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
     /**
-     * webXR模式开始，webxr session完成坐标系矫正
+     * 预加载点位图片资源
+     * @param pano - 观察点序号
+     * @param callback - 加载完成回调, 并传递加载用时。
+     * @returns 加载完成的 Promise 参数同 callback
      */
-    webXRSessionStart(): void;
+    preloadPano(pano: Pano | PanoId | number, callback?: (costs: number) => void): Promise<number>;
     /**
-     * webXR模式结束,webxr session销毁
+     * 计算三维坐标对应到屏幕的二维坐标
+     * @description
+     * 如果三维坐标不在屏幕中，则返回 null
+     * @param vector - 三维坐标
+     * @param testModel - 是否计算模型遮挡
+     * @returns 二维坐标 或者 null
      */
-    webXRSessionEnd(): void;
+    project2d(vector: THREE_2.Vector3, testModel?: boolean): THREE_2.Vector2 | null;
     /**
-     * axes代表控制杆，axes数组的0-1元素分别代表左控制器的左（-1）右（1）,左控制器的上（-1）下（1），axes数组的2-3元素同理
+     * 获取当前在屏幕视锥中的 mesh。
+     * @param object - 如果传入则检查这个对象中的mesh，如果不传，则检查整个 scene
      */
-    webXRControllerEvent(type: WebXRControllerType, key: WebXRControllerKey, params: WebXRControllerParams): void;
-};
-
-export declare class CullingVolume {
-    static get MASK_OUTSIDE(): number;
-    static get MASK_INSIDE(): number;
-    static get MASK_INDETERMINATE(): number;
-    planes: THREE_2.Plane[];
-    constructor(planes?: THREE_2.Plane[]);
-    setFromFrustum(frustum: THREE_2.Frustum): this;
-    computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
-    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
-}
-
-/**
- * URL 地址的转换
- * @param source - url 原地址
- * @param options - url 转换参数
- * @returns url 转换结果
- */
-export declare function defaultImageURLTransform(source: string, options: ImageURLOptions): string;
-
-export declare interface DepthPanoramaControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
-    /** 最远可移动观察点距离 */
-    maxAccessibleDistance?: number;
+    getRenderObjects(object?: THREE_2.Object3D): THREE_2.Object3D[];
+    getCurrentState(): State;
     /**
-     * 点击地面观察点标识的判定范围
+     * 设置 State
      * @description
-     * 如果在判定范围内则确定去到目标点，
-     * 否则寻找点击位置方向最适合的点（可能会走到一个离相机更近的点）。
+     * ```text
+     * five 设置了以下状态
+     *
+     * - mode: Mode
+     * - panoIndex: number
+     * - longitude: number
+     * - latitude: number
+     * - fov: number
+     * - offset: THREE.Vector3
+     *
+     * 可以通过 five.state 和 five.setState 来获取和设置。
+     * 通过 state 设置后，five 会通过合适的动画运动来达到设置的位置。
+     * 来迎合一些通过数据驱动的场景。
+     * ```
+     * @param state - 目标状态
+     * @param immediately - 是否马上转换，马上转换会尽快达到目标状态，尽量减少中间状态，更少动画。
+     * @param userAction - 是否是用户触发的动作
      */
-    panoTapTriggerRadius?: number;
-    /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: (panoId: WorkPanoId) => PanoCircleMeshInterface;
-}
-
-/**
- * Five 事件列表
- * @description
- * 可以通过 `five.on(METHOD_NAME, METHOD)` 调用
- */
-export declare interface EventCallback extends EventTypes {
-}
-
-/**
- * Five 事件列表
- * @description
- * 具体事件列表 请查看 {@link EventCallback}
- */
-export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROLLER_EVENT_NAMES[number]> & {
+    setState(state: Partial<State>, immediately?: boolean, userAction?: boolean): void;
+    aroundScissor(callback: () => void): void;
+    private syncState;
     /**
-     * 内部错误
-     * @param error - 错误对象
+     * 当前页面静态
      */
-    error(error: Error): void;
+    ready(args?: {
+        tile?: boolean;
+    }): Promise<void>;
     /**
-     * 准备加载 Work 数据
-     * @param input - 输入的 work
-     * @param works - 归一化的标准 work
-     * @param state - 加载时的姿态
+     * 请求全屏
      */
-    willLoad(input: any, works: Works, state: Partial<State>): void;
+    requestFullscreen(): void;
     /**
-     * 开始加载 Work 数据
-     * @param input - 输入的 work
-     * @param works - 归一化的标准 work
-     * @param state - 加载时的姿态
+     * 退出全屏
      */
-    load(input: any, works: Works, state: Partial<State>): void;
+    exitFullscreen(): void;
+    private throwError;
+    private loadModel;
+    private commonParams;
+    private applyController;
+    /** 移除事件绑定 */
+    private removeEventListeners;
+}
+
+/** Five 初始化参数 */
+export declare interface FiveInitArgs {
     /**
-     * 加载完 Work 数据
-     * @param input - 输入的 work
-     * @param works - 归一化的标准 work
+     * 外部传入的 `THREE.WebGLRenderer`。
+     * @description
+     * 如果需要使用 `scissor` 分割画布功能，则必须使用外部传入 renderer，
+     * 并且设置为 `preserveDrawingBuffer: false`。
+     * 如果设置了 `renderer`, 则 `preserveDrawingBuffer`
+     * `backgroundColor` `backgroundAlpha` `antialias`
+     * 均不再生效。
      */
-    loaded(input: any, works: Works): void;
+    renderer?: THREE_2.WebGLRenderer;
     /**
-     * 模型开始加载
-     * @param workModel - 归一化的标准 work 中的 model 值
+     * 内部 `THREE.WebGLRenderer` 是否通过像素拷贝的方式绘制。
+     * @description
+     * 当你想做屏幕截图等要确定取得屏幕像素时，请设置为 `true`。
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `false`
      */
-    modelWillLoad(workModel: WorkModel): void;
+    preserveDrawingBuffer?: boolean;
     /**
-     * 模型加载错误
-     * @param error - 错误对象
-     * @param model - 加载完的 model
+     * 输出画面的背景颜色。
+     * @description
+     * 通过数字类型传入。
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `0x181A1C`
+     * @example
+     * ```
+     * backgroundColor: 0xffffff // 白色
+     * backgroundColor: 0xff0000 // 红色
+     * ```
      */
-    modelLoadError(error: Error, model: Model): void;
+    backgroundColor?: number;
     /**
-     * 模型加载完成
-     * @param models - 加载完的 model
+     * 输出画面的背景透明度
+     * @description
+     * 通过数字类型传入。取值范围 [0-1]
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `1`
      */
-    modelLoaded(models: Models): void;
+    backgroundAlpha?: number;
     /**
-     * 模型楼层切换
-     * @param shownFloor - 模型楼层
+     * 是否开启 `THREE.WebGLRenderer` 的抗锯齿功能
+     * @description
+     * 这个抗锯齿功能是 `WEBGL` 自带的抗锯齿，并不是类似 fxaa taa 等后处理方式，比较吃性能。
+     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
+     * @default `false`
      */
-    modelShownFloorChange(shownFloor: number | null): void;
+    antialias?: boolean;
     /**
-     * 渲染循环
-     * @param rendered - 是否渲染了
+     * 屏幕渲染区域
+     * @description
+     * 请确保设置了 `renderer` 参数，`scissor` 参数才可生效
+     * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+     * @example
+     * ```
+     * scissor: { left: 0.75, bottom: 0, width: 0.25, height: 1 }
+     * ```
      */
-    renderFrame(rendered: boolean): void;
+    scissor?: Scissor;
     /**
-     * 当前 fps 变化
-     * @param fps - 当前刷新率
+     * 是否自动播放。
+     * @description
+     * 播放即把内存中计算的内容渲染到画面上。play则是进行每帧播放。
+     * 如果 `play: false` 则不自动播放。屏幕不显示。
+     * 你还可以通过 `five.play()` `five.pause()` 的方式来控制播放。
+     * @default `true`
      */
-    fps(fps: number): void;
+    play?: boolean;
     /**
-     * 当目标 state 变化时
-     * @param state - 当前姿态状态
-     * @param userAction - 是否用户触发
+     * 全景图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的全景图片在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
      */
-    stateChange(state: State, userAction: boolean): void;
+    imageOptions?: ImageOptions;
     /**
-     * 当前实时 state 变化时
-     * @param state - 当前姿态状态
-     * @param userAction - 是否用户触发
+     * 模型贴图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
      */
-    currentStateChange(state: State, userAction: boolean): void;
+    textureOptions?: TextureOptions;
     /**
-     * 当 setState 方法被调用
-     * @param state - 当前姿态状态
+     * 是否按需渲染
+     * @description
+     * 按需渲染时，如果页面中的渲染有 `needsRender: true` 属性。或者 `five.needsRender: true` 时
+     * 才会重新渲染屏幕，降低无用渲染产生的消耗。
+     * @default `true`
      */
-    setState(state: State): void;
+    onlyRenderIfNeeds?: boolean;
     /**
-     * 当 state 被同步完成时
-     * @param state - 当前姿态状态
+     * 最高 fps 限制
+     * @description
+     * 如果为 `false`, 则不限制。最好也就是屏幕刷新率，不会再高了。
+     * @default `false`
      */
-    stateSynced(state: State): void;
+    maxFps?: number | false;
     /**
-     * 意图要移动到某个点时, 可以通过 return false 阻止
-     * @param panoId - 意图要移动到点位
-     * @param options - 移动参数
-     * @param userAction - 是否用户触发
-     * @returns 可以通过 return false 阻止
+     * 外挂视频对象。
+     * @description
+     * 当点位中有视频元素，则会使用。如果不传入也会外部新建，
+     * 加入传入的原因是，视频自动播放在不同浏览器或者 webview 中有不同的特性。
+     * 给予更多外部操作的空间。
      */
-    wantsMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void | false;
+    videoInstance?: HTMLVideoElement;
+    /** 全景图游走模式下的特定参数 */
+    panorama?: ControllerCustomInitTypes["Panorama"];
+    /** 模型游走模式下的特定参数 */
+    model?: ControllerCustomInitTypes["Model"];
+    /** 模型查看模式下的特定参数 */
+    floorplan?: ControllerCustomInitTypes["Floorplan"];
+    /** 户型图模式下的特定参数 */
+    topview?: ControllerCustomInitTypes["Topview"];
+    /** 地图模式下的特定参数 */
+    mapview?: ControllerCustomInitTypes["Mapview"];
+    /** VR眼镜模式下的特定参数 */
+    vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
+    /** XR眼镜模式下的特定参数 */
+    xrPanorama?: ControllerCustomInitTypes["XRPanorama"];
     /**
-     * 同 wantsMoveToPano
+     * 模式间切换时的过度动画时间
      * @description
-     * @param panoId - 意图要移动到点位
-     * @param options - 移动参数
-     * @param userAction - 是否用户触发
-     * @returns 可以通过 return false 阻止
+     * 单位毫秒
+     * @default `800`
      */
-    wantsToMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void;
+    modeChangeDuration?: number;
     /**
-     * 意图要切换到某个模态， 可以通过 return false 阻止
-     * @param mode - 意图要切换到的模态
-     * @param prevMode - 当前模态
-     * @returns 可以通过 return false 阻止
+     * 是否支持滚轮
      */
-    wantsChangeMode(mode: Mode, prevMode: Mode): void | false;
+    enableWheel?: boolean;
     /**
-     * 模态切换完成
-     * @param mode - 切换到的模态
-     * @param prevMode - 上本质是一个模态
-     * @param panoIndex - 初始化动画结束后的点位下标
-     * @param toPose - 初始化动画结束后的状态
-     * @param userAction - 是否用户触发
+     * 插件定义
+     * @description
+     * 详见插件部分。
      */
-    modeChange(mode: Mode, prevMode: Mode, panoId: WorkPanoId, toPose: Pose, userAction: boolean): void;
+    plugins?: (FivePlugin<void> | FivePluginInit<FivePlugin<any, any>> | FivePluginInit<FivePlugin<void, any>>)[];
     /**
-     * 帮助元素显应的变换
-     * @param visible - 帮助元素的是否开启
+     * 是否展示 powered by 如视
      */
-    helpersVisibleChange(visible: boolean): void;
+    poweredByRealsee?: boolean;
     /**
-     * 网络资源分析
-     * @param source - 资源地址
-     * @param state - 状态
-     * @param detail - 详情
-     */
-    network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
-    /** five 被析构。 插件中请监听用于自身析构 */
-    dispose(): void;
-};
-
-/**
- * 如视 VR Web展示器
- *
- * @example
- * ```
- * // 初始化构造函数
- * const five = new Five();
- * // 将绘制区域添加到页面上
- * five.appendTo(document.body);
- * // 加载 Work 数据
- * five.load({...});
- * ```
- */
-export declare class Five extends Subscribe<EventTypes> {
-    static get version(): string;
-    static get dracoPath(): string;
-    static set dracoPath(path: string);
-    /**
-     * Five 的显示模式，可以通过 `five.changeMode` `five.setState` 来切换
-     * @description
-     * ```text
-     * Panorama 全景图游走模式
-     * Model 模型游走模式
-     * Floorplan 模型查看模式
-     * Topview 户型图模式
-     * DepthPanorama 深度图游走模式
-     * VRPanorama VR眼镜模式
-     * XRPanorama VR硬件模式
-     * ```
-     */
-    static Mode: Mirror<Mode>;
-    /**
-     * @deprecated
-     * 请使用 `import { Line } from "@realsee/five/line"` 代替;
-     */
-    static Line: any;
-    /**
-     * 自动播放状态是否暂停
-     * @description
-     * 可以通过 `five.play` `five.pause` 方法播放或暂停
-     */
-    paused: boolean;
-    /** 当前点位序号 */
-    panoId: WorkPanoId;
-    /** 当前展示的模式 */
-    currentMode: Mode;
-    /** 内部使用的 `THREE.Scene` */
-    scene: Scene;
-    /** 内部使用的 `Camera` */
-    camera: Camera;
-    /**
-     * 当前设置的 `scissor`
-     * @description
-     * 可通过初始化，或者 setScissor 方式设置
-     * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
-     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
-     * @example
-     * ```
-     * scissor: { left: 0.75, bottom: 0, width: 0.25, height: 1 }
-     * ```
-     */
-    scissor: Scissor;
-    /**
-     * 当前使用的 THREE.WebGLRenderer。
-     * @description
-     * 如果初始化时传入了 `renderer` 则直接时该值
-     * 否则会通过 `preserveDrawingBuffer` `backgroundColor` `backgroundAlpha` `antialias` 创建一个 `THREE.WebGLRenderer`
+     * 是否使用webgl2渲染执行环境, 默认值 false
      */
-    renderer?: THREE_2.WebGLRenderer;
-    /** 当前加载的模型 */
-    models: Models;
+    webgl2?: boolean;
     /**
-     * 是否需要渲染
-     * @description
-     * 如果初始化设置了 `onlyRenderIfNeeds: true`, 则会激活按需渲染
-     * 可以通过设置 `five.needsRender = true` 来告知，five 会在下一帧渲染画面。
+     * 请求代理
+     * @param url - 发起的请求
+     * @returns 返回的请求
      */
-    needsRender: boolean;
+    requestProxy?(url: string): string | Promise<string>;
+}
+
+export declare interface FiveLoadOptions {
+    /** 切换运动时间 */
+    duration?: number;
+    /** 切换运动全景图效果 */
+    effect?: MovePanoEffect;
+    /** 全景图游走模式下的特定参数 */
+    panorama?: ControllerCustomInitTypes["Panorama"];
+    /** 模型游走模式下的特定参数 */
+    model?: ControllerCustomInitTypes["Model"];
+    /** 模型查看模式下的特定参数 */
+    floorplan?: ControllerCustomInitTypes["Floorplan"];
+    /** 户型图模式下的特定参数 */
+    topview?: ControllerCustomInitTypes["Topview"];
+    /** 地图模式下的特定参数 */
+    mapview?: ControllerCustomInitTypes["Mapview"];
+    /** VR眼镜模式下的特定参数 */
+    vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
+    /** XR眼镜模式下的特定参数 */
+    xrPanorama?: ControllerCustomInitTypes["XRPanorama"];
     /**
      * 全景图的配置参数
      * @description
      * 可以动态对配置在 `work` 数据中的全景图片在 runtime 做 url 调整。
      * 平衡加载时间和图片质量
      */
-    imageOptions: ImageOptions;
+    imageOptions?: ImageOptions;
     /**
      * 模型贴图的配置参数
      * @description
      * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
      * 平衡加载时间和图片质量
      */
-    textureOptions: TextureOptions;
+    textureOptions?: TextureOptions;
+    "3d-tiles"?: {
+        /** 调试模式 */
+        debug?: boolean;
+        /** 显示图层 */
+        showLayers?: boolean | string[];
+        /** 可观测区域 */
+        viewerRequestVolume?: BoundingVolume;
+        /** 模型显示最小细化层级 */
+        minLevelOfDetail?: number;
+        /** 模型显示最大细化层级 */
+        maxLevelOfDetail?: number;
+        /** 模型最大内存缓存 */
+        maxMemoryUsage?: number;
+        /** 模型网络最大请求并发数 */
+        maxRequests?: number;
+        /** 模型屏幕空间误差计算最大值 */
+        maxScreenSpaceError?: number;
+    };
+}
+
+/**
+ * Five 插件
+ * [[include:plugins.md]]
+ * @template Parameters - 插件参数, 没有参数则为 void
+ * @template Returns - 如果有参数则插件暴露的 api，没有参数则不传
+ */
+export declare type FivePlugin<Parameters = void, Returns = void> = Parameters extends void ? ((five: Five) => Returns) : ((five: Five, parameters: Parameters) => Returns);
+
+/**
+ * 获取插件在Five中的初始化结构
+ * @template T - Five 插件
+ */
+export declare type FivePluginInit<T extends FivePlugin<any, any>> = Parameters<T>[1] extends undefined ? [
+Plugin: T,
+instanceName: null | string
+] : [
+Plugin: T,
+instanceName: null | string,
+parameters: Parameters<T>[1]
+];
+
+/**
+ * 获取插件暴露的 api
+ * @template T - Five 插件
+ */
+export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
+
+export declare interface FloorplanControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
+    /** 默认俯仰角 */
+    defaultLatitude?: number;
+    /** 最大俯仰角 */
+    maxLatitude?: number;
+    /** 最小俯仰角 */
+    minLatitude?: number;
+    /** 默认相机可视角度（垂直），可作为 `zoom` */
+    defaultFov?: number;
+    /** 最大相机可视角度 */
+    maxFov?: number;
+    /** 最小相机可视角度 */
+    minFov?: number;
+    /** 鼠标焦点环自定义创建器 */
+    intersectMeshCreator?: () => IntersectMeshInterface;
+}
+
+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;
+
+/**
+ * 图片参数
+ */
+export declare interface ImageOptions {
     /**
-     * 模型lod的配置参数
-     * @description
-     * 可以配置加载模型lod的相关参数
+     * url 地址转化
+     * @param url - 原始地址
+     * @param options - 当前地址参数
+     * @returns 转化后地址
      */
-    modelLodOptions: ModelLodOptions;
+    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<{
+    webp: boolean;
+    avif: boolean;
+    heif: 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, premultipliedAlpha, stencil, backgroundColor, backgroundAlpha, pixelRatio, antialias, webgl2, }: {
+        preserveDrawingBuffer?: boolean;
+        premultipliedAlpha?: boolean;
+        stencil?: 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 extends THREE_2.Intersection {
+    /** 楼层 */
+    floor: number;
+    model?: Model;
+    viewLayer?: ModelViewLayer;
+}
+
+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 = {
     /**
-     * 模型贴图的配置参数
-     * @description
-     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
-     * 平衡加载时间和图片质量
+     * 模态间切换动画开始
+     * @param panoIndex - 当前点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
      */
-    videoTexture: THREE_2.VideoTexture;
+    initAnimationWillStart(panoIndex: number, pose: Pose, userAction: boolean): void;
     /**
-     * 当前状态
-     * @description
-     * ```text
-     * five 设置了以下状态
-     *
-     * - mode: Mode
-     * - panoIndex: number
-     * - longitude: number
-     * - latitude: number
-     * - fov: number
-     * - offset: THREE.Vector3
-     *
-     * 可以通过 five.state 和 five.setState 来获取和设置。
-     * 通过 state 设置后，five 会通过合适的动画运动来达到设置的位置。
-     * 来迎合一些通过数据驱动的场景。
-     * ```
+     * 模态间切换动画结束
+     * @param panoIndex - 当前点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
      */
-    state: State;
-    /** 插件暴露的方法 */
-    plugins: {
-        [key: string]: FivePluginInstance<any>;
-    };
-    ident: string;
-    /** 包围盒子 */
-    private boundingMesh;
-    private stopAnimationLoop?;
-    private fps;
-    private modelGroup;
-    private helperGroup;
-    private modeChangeDuration;
-    private onlyRenderIfNeeds;
-    private poweredByRealsee;
-    private controller?;
-    private destroyed;
-    private stateSynced;
-    private controllerInits;
-    private extraElements;
-    private getPixelsRenderTarget;
-    private readyCallbacks;
-    private modelPending;
-    private syncingState;
+    initAnimationEnded(panoIndex: number, pose: Pose, userAction: boolean): void;
     /**
-     * 是否开启 IOS EDR 模式
-     * 需要客户端配合
-     * 并且开启 five.enablepostProcessing = true
+     * 意图要触发手势， 可以通过 `return false` 阻止
+     * @param type - 手势类型
+     * @param pointers - 手指位置
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
      */
-    private _enableIOSEDR;
-    private lastLoadWorkTask;
-    private requestProxy;
-    private networkSubscribe;
-    private screenBuffers?;
-    private analysis?;
-    private renderSwitch01;
+    wantsGesture(type: GestureTypes, pointers: {
+        x: number;
+        y: number;
+        delta?: number;
+    }[], final: boolean): void | false;
     /**
-     * gpu_picking
+     * 手势 触发
+     * @param type - 手势类型
+     * @param pointers - 手指位置
+     * @param final - 是否手势结束
      */
-    private gpuPickingRenderTarget;
-    private meshReplaceMaterialMap;
-    private meshOriginMaterialMap;
-    private copyEffect;
-    constructor(initArgs?: FiveInitArgs);
-    get panoIndex(): number;
+    gesture(type: GestureTypes, pointers: {
+        x: number;
+        y: number;
+        delta?: number;
+    }[], final: boolean): void;
     /**
-     * GPU Picking 获取选中的 mesh
-     * @param x - 屏幕坐标 x
-     * @param y - 屏幕坐标 y
-     * @param colorMap - 需要选取的 mesh 的颜色与 uuid 的映射
-     * @param color - 指定的模型颜色
-     * @returns 选中 mesh 的 uuid
+     * 意图要触发 pan 手势(滑动屏幕)， 可以通过 `return false` 阻止
+     * @param pose - 意图的相机姿态
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
      */
-    getGPUPicking(x: number, y: number, colorMap: {
-        [key: string]: THREE_2.Color;
-    }, pixelRatio?: number, color?: THREE_2.Vector3): string | false;
+    wantsPanGesture(pose: Pose, final: boolean): void | false;
     /**
-     * 析构 five 对象。
-     * @description
-     * 一旦调用了析构方法，则不能再使用当前 five 对象了。
-     * 你可以新建一个新的。
+     * pan 手势(滑动屏幕) 被触发
+     * @param pose - 相机姿态
+     * @param final - 是否手势结束
      */
-    dispose(): void;
+    panGesture(pose: Pose, final: boolean): void;
     /**
-     * 设置 `scissor`
-     * @param scissor - 指定区域
-     * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
-     * 请确保在 five 初始化时传入 `renderer` 对象
-     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
-     * @example
-     * ```
-     * five.setScissor({ left: 0.75, bottom: 0, width: 0.25, height: 1 })
-     * ```
+     * 意图要触发 tap 手势(点击屏幕)， 可以通过 `return false` 阻止
+     * @param raycaster - 点击对应的三维射线
+     * @param tapPosition - 点击对应的屏幕位置
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
      */
-    setScissor(scissor: Scissor): void;
+    wantsTapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void | false;
     /**
-     * 帮助元素显示/隐藏
+     * tap 手势(点击屏幕) 被触发
+     * @param raycaster - 点击对应的三维射线
+     * @param tapPosition - 点击对应的屏幕位置
+     * @param final - 是否手势结束
      */
-    get helperVisible(): boolean;
-    set helperVisible(visible: boolean);
+    tapGesture(raycaster: THREE_2.Raycaster, tapPosition: THREE_2.Vector2, final: boolean): void;
     /**
-     * 是否开启 IOS EDR 模式
-     * 需要客户端配合
-     * 并且开启 five.enablepostProcessing = true
+     * 意图要触发 pinch 手势(双指缩放)，可以通过 `return false` 阻止
+     * @param scale - 缩放数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
      */
-    get enableIOSEDR(): boolean;
-    set enableIOSEDR(enable: boolean);
+    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;
     /**
-     * 是否开启EDL模式
+     * 意图要触发 鼠标滚轮 可以通过 `return false` 阻止
+     * @param delta - 滚轮数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
      */
-    get enableEDL(): boolean;
-    set enableEDL(enable: boolean);
+    wantsMouseWheel(delta: number, nextFov: number, final: boolean): void | false;
     /**
-     * 是否开启后处理
+     * 鼠标滚轮被触发
+     * @param delta - 滚轮数值
+     * @param nextFov - 意图的fov变更
+     * @param final - 是否手势结束
      */
-    get enablePostProcessing(): boolean;
-    set enablePostProcessing(enable: boolean);
-    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "depthPanorama" | "vrPanorama" | "imageOptions" | "textureOptions">): void;
+    mouseWheel(delta: number, fov: number, final: boolean): void;
     /**
-     * 将显示区域加载到页面 DOM 中
-     * @description
-     * 如果你是传入的 `renderer`. 则你需要自行来方式显示区域该方法并不生效
-     *
-     * @param element - 加载到页面的 DOM 元素
-     * @param size - 显示区域尺寸 默认铺满这个 DOM 元素
+     * 意图要触发 pan 手势(滑动屏幕) 的惯性运动, 可以通过 `return false` 阻止
+     * @param pose - 意图的相机姿态
+     * @param final - 是否手势结束
+     * @returns 可以通过 `return false` 阻止
      */
-    appendTo(element: HTMLElement, size?: {
-        width?: number;
-        height?: number;
-    }): void;
+    wantsInteriaPan(pose: Pose): void | false;
     /**
-     * 设置显示区域尺寸
-     * @description
-     * 如果你是传入的 `renderer`. 则你需要自行来设置显示区域尺寸，该方法并不生效
-     *
-     * @param size - 显示区域尺寸 默认铺满这个 DOM 元素
-     * @param pixelRatio - 像素比 默认继承之前的设置
+     * pan 手势(滑动屏幕) 的惯性运动
+     * @param pose - 意图的相机姿态
+     * @param final - 是否手势结束
      */
-    refresh(size?: {
-        width?: number;
-        height?: number;
-    }, pixelRatio?: number): void;
+    interiaPan(pose: Pose, final: boolean): void;
     /**
-     * 绑定一个额外 DOM 区域，接受触控/鼠标事件
-     * @returns 解除该绑定
+     * 意图要变化相机的可视角度 可以通过 `return false` 阻止
+     * @deprecated
+     * 建议通过 初始化设置的 `defaultFov`, `maxFov`, `minFov` 来限制
+     * @param fov - 意图要变化相机的可视角度
+     * @returns 可以通过 `return false` 阻止
      */
-    addExtraElement(element: HTMLElement): () => void;
+    wantsChangeCameraFov(fov: number): void | false;
     /**
-     * 解除绑定的一个额外 DOM 区域
+     * 相机姿态变化
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
      */
-    removeExtraElement(element: HTMLElement): void;
+    cameraUpdate(pose: Pose, userAction: boolean): void;
     /**
-     * 获取当前相机姿态, 可以使用 getCurrentState 代替
+     * 相机姿态中可视角度变化
+     * @param fov - 相机的可视角度
+     * @param userAction - 是否用户触发
      */
-    getPose(): Pose;
-    getSize(target: THREE_2.Vector2): THREE_2.Vector2;
-    getDrawingBufferSize(target: THREE_2.Vector2): THREE_2.Vector2;
+    cameraFovUpdate(fov: Pose["fov"], userAction: boolean): void;
     /**
-     * 移动相机。（不触发点位移动）
-     * @description
-     * 如果动画中途被打断（用户触发行为，或者调用 setState, load, changeMode）的等
-     * 会 Promise.reject。运动完成则 Promise.resolve
-     * @param pose - 相机目标位置
-     * @param duration - 动画触发的时常
+     * 相机姿态中相机位置变化
+     * @param offset - 相机位置
      * @param userAction - 是否用户触发
-     * @returns Promise 是否移动成功
      */
-    updateCamera(pose: Partial<Omit<Pose, "offset">>, duration: number, userAction?: boolean): Promise<void>;
+    cameraPositionUpdate(offset: Pose["offset"], userAction: boolean): void;
     /**
-     * 通过帧动画移动相机。（不触发点位移动）
-     * @description
-     * 如果动画中途被打断（用户触发行为，或者调用 setState, load, changeMode）的等
-     * 会 Promise.reject。运动完成则 Promise.resolve
-     * @param keyframes - 动画帧
-     * @param duration - 动画触发的时常
+     * 相机姿态中相机方向变化
+     * @param coordinates - 相机姿态的俯仰角和偏航角
      * @param userAction - 是否用户触发
-     * @returns Promise 是否移动成功
      */
-    updateCameraWithKeyframes(keyframes: MotionKeyframe<Exclude<keyof Pose, "offset">>[], duration: number, userAction?: boolean): Promise<void>;
+    cameraDirectionUpdate(coordinates: Pick<Pose, "longitude" | "latitude">, userAction: boolean): void;
     /**
-     * 获取当前相机经纬度
-     * @deprecated 请使用使用 getPose
+     * 鼠标焦点环位置被重新计算
+     * @param intersection - 焦点碰撞结果
+     * @param mesh - 焦点环 mesh
      */
-    getLongitudeAndLatitude(): Pick<Pose, "longitude" | "latitude">;
+    intersectionOnModelUpdate(intersection: Intersection, mesh: THREE_2.Object3D): void;
     /**
-     * 获取当前相机位置
-     * @deprecated 请使用使用 getPose
+     * 意图要展示鼠标焦点环，可以通过 `return false` 阻止
+     * @param intersection - 焦点碰撞结果
+     * @returns 可以通过 `return false` 阻止
      */
-    getOffset(): Pose["offset"];
+    wantsShowIntersectionOnModel(raycaster: THREE_2.Raycaster): void | false;
+    /** 鼠标焦点环被隐藏 */
+    intersectionHidden(): void;
     /**
-     * 获取当前相机的姿态（用于内部的 python 脚本截图）
-     * @deprecated 这是用于内部的 python 脚本截图
+     * 意图要移动到某个点时, 可以通过 return false 阻止
+     * @param panoIndex - 意图要移动到点位
+     * @param options - 移动参数
+     * @param userAction - 是否用户触发
+     * @returns 可以通过 return false 阻止
      */
-    getCameraLocal(): {
-        theta: number;
-        phi: number;
-        lookAtVector: THREE_2.Vector3;
-    };
-    /** 当前加载的 work 数据 */
-    get works(): Works;
-    get work(): Work | undefined;
-    get model(): Model;
+    wantsMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void | false;
     /**
-     * 加载 Work 数据
-     * @param inputWork - Work 数据
-     * @param state - 初始化姿态
-     *  - "inherit" 使用当前姿态
-     *  - "initial" 使用 Work 数据中的 initial 姿态
-     *  - State 自定义姿态
-     * @param duration - 切换时间
+     * 同 wantsMoveToPano
+     * @description
+     * @param panoIndex - 意图要移动到点位
+     * @param options - 移动参数
+     * @param userAction - 是否用户触发
+     * @returns 可以通过 return false 阻止
      */
-    load(inputWork: string | Work | LooseWork | string[] | Work[] | LooseWork[] | LooseWorkWithExtrinsics[] | Promise<Work | LooseWork | Work[] | LooseWork[] | LooseWorkWithExtrinsics[]>, state?: "inherit" | "initial" | Partial<State>, duration?: number, userAction?: boolean): Promise<void>;
-    private load_;
+    wantsToMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void;
     /**
-     * 切换模态
-     * @param mode - 切换到的模态
-     * @param state - 切换完成时的姿态
-     * @param duration - 模态切换动画用时
-     * @param userAction - 是否时用户动作触发 默认 true
-     * @param force - 必须重新初始化 controller
+     * 观察点位被选择
+     * @param panoIndex - 选择的点位
      */
-    changeMode<T extends Mode>(mode: T, state?: Partial<Omit<State, "mode">>, duration?: number, userAction?: boolean, force?: boolean): Promise<void>;
+    panoSelected(panoIndex: number | null): void;
     /**
-     * 获取画面中的像素颜色
-     * @param x - 获取像素区域的起始坐标 x
-     * @param y - 获取像素区域的起始坐标 y
-     * @param width - 获取像素区域的宽度
-     * @param height - 获取像素区域的高度
-     * @param pixelRatio - 获取区域的像素比
-     * @returns rgba颜色平铺的 Uint8Array
+     * 开始加载并移动到某个观察点位
+     * @description
+     * 可 panoWillArrive 相比
+     * - moveToPano 在加载全景图资源前触发
+     * - panoWillArrive 在加载全景图资源后触发
+     * @param panoIndex - 移动到的点位
+     * @param userAction - 是否用户触发
      */
-    getPixels(x: number, y: number, width: number, height: number, pixelRatio?: number): Uint8Array;
+    moveToPano(panoIndex: number, userAction: boolean): void;
     /**
-     * 获取显示用的画布（Canvas DOM节点）
+     * 移动中， 会告知移动状态（耗时百分比）
+     * @param panoIndex - 将要移动到的点位下标
+     * @param prevPanoIndex - 上一个点位下标
+     * @param progress - 整个过程经度 [0-1]
      */
-    getElement(): HTMLCanvasElement | undefined;
+    movingToPano(panoIndex: number, prevPanoIndex: number, progress: number): void;
     /**
-     * 获取观测点
+     * 开始加载某个观察点的全景资源
+     * @param pano - 移动到的点位
      */
-    get observers(): WorkObserver[];
+    panoWillLoad(panoIndex: number): void;
     /**
-     * 强制渲染
-     * @description
-     * 调用 `five.render()` 和设置 `five.needsRender = true` 均可在按需渲染时，使得画面渲染一次
-     * 区别在于：
-     * - `five.needsRender = true` 为在下帧渲染画面
-     * - `five.render()` 在当前帧渲染画面
-     * 推荐使用 `five.needsRender = true`, 可以更加流畅。但是如果需要截图等同步操作，可以使用 `five.render()`
-     *
-     * @param callback - 渲染完成回调
+     * 某个观察点的全景资源加载完成
+     * @param panoIndex - 对应的点位
      */
-    render(callback?: () => void, updateObjectResolution?: boolean): THREE_2.WebGLRenderTarget;
-    updateTime(time: number, deltaTime: number, ...args: any[]): void;
+    panoLoaded(panoIndex: number): void;
     /**
-     * 暂停自动播放
+     * 开始移动到某个观察点位
+     * @description
+     * 和 moveToPano 相比
+     * - moveToPano 在加载全景图资源前触发
+     * - panoWillArrive 在加载全景图资源后触发
+     * @param panoIndex - 移动到点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
      */
-    pause(): void;
-    play(): void;
+    panoWillArrive(panoIndex: number, pose: Pose, userAction: boolean): void;
     /**
-     * 转化到 Panorama 模态，并移动到对应序号的观察点。
-     * @param panoIndex - 观察点序号
-     * @param options - 移动点位参数
-     * @param userAction - 是否用户触犯
+     * 移动到某个观察点位
+     * @param panoIndex - 移动到点位
+     * @param pose - 相机姿态
+     * @param userAction - 是否用户触发
      */
-    moveToPano(panoId: WorkPanoId, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
-    moveToPano(panoIndex: number, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
+    panoArrived(panoIndex: number, pose: Pose, userAction: boolean): void;
     /**
-     * 预加载点位图片资源
-     * @param panoIndex - 观察点序号
-     * @param callback - 加载完成回调, 并传递加载用时。
-     * @returns 加载完成的 Promise 参数同 callback
+     * 某个观察点的全景资源加载失败
+     * @param error - 错误对象
+     * @param panoIndex - 对应的点位
      */
-    preloadPano(panoId: WorkPanoId, callback?: (costs: number) => void): Promise<number>;
-    preloadPano(panoIndex: number, callback?: (costs: number) => void): Promise<number>;
+    panoLoadError(error: Error, panoIndex: number): void;
     /**
-     * 计算三维坐标对应到屏幕的二维坐标
+     * 移动到某个观察点位被取消
      * @description
-     * 如果三维坐标不在屏幕中，则返回 null
-     * @param vector - 三维坐标
-     * @param testModel - 是否计算模型遮挡
-     * @returns 二维坐标 或者 null
+     * 这个有一些情况会导致
+     * - 移动过程中切换模态
+     * - 移动过程中 five 被析构
+     * - 移动过程点击切换到另一个点位
+     * @param panoIndex - 对应的点位
      */
-    project2d(vector: THREE_2.Vector3, testModel?: boolean): THREE_2.Vector2 | null;
+    moveToPanoCanceled(panoIndex: number): void;
     /**
-     * 获取当前在屏幕视锥中的 mesh。
-     * @param object - 如果传入则检查这个对象中的mesh，如果不传，则检查整个 scene
+     * 观察点的全景资源开始加载
+     * @param panoIndex - 加载点位
      */
-    getRenderObjects(object?: THREE_2.Object3D): THREE_2.Object3D[];
-    getCurrentState(): State;
+    textureStartLoad(panoIndex: number): void;
     /**
-     * 设置 State
-     * @description
-     * ```text
-     * five 设置了以下状态
-     *
-     * - mode: Mode
-     * - panoIndex: number
-     * - longitude: number
-     * - latitude: number
-     * - fov: number
-     * - offset: THREE.Vector3
-     *
-     * 可以通过 five.state 和 five.setState 来获取和设置。
-     * 通过 state 设置后，five 会通过合适的动画运动来达到设置的位置。
-     * 来迎合一些通过数据驱动的场景。
-     * ```
-     * @param state - 目标状态
-     * @param immediately - 是否马上转换，马上转换会尽快达到目标状态，尽量减少中间状态，更少动画。
-     * @param userAction - 是否是用户触发的动作
+     * 观察点的全景资源加载中，可获取到进度
+     * @param progress - 加载进度 [0-1]
+     * @param panoIndex - 加载点位下标
      */
-    setState(state: Partial<State>, immediately?: boolean, userAction?: boolean): void;
-    aroundScissor(callback: () => void): void;
-    private syncState;
+    textureLoading(progress: number, panoIndex: number): void;
     /**
-     * 当前页面静态
+     * 观察点的全景资源加载被中止
+     * @param panoIndex - 加载点位
      */
-    ready(args?: {
-        tile?: boolean;
-    }): Promise<void>;
+    textureAbort(panoIndex: number): void;
     /**
-     * 请求全屏
+     * 观察点的全景资源加载失败
+     * @param error - 错误对象
+     * @param panoIndex - 加载点位
      */
-    requestFullscreen(): void;
+    textureError(error: Error, panoIndex: number): void;
     /**
-     * 退出全屏
-     */
-    exitFullscreen(): void;
-    private throwError;
-    private loadModel;
-    private commonParams;
-    private applyController;
-    /** 移除事件绑定 */
-    private removeEventListeners;
-    /** 销毁GPU Picking 所用的材质 */
-    private diposeGPUPickingMaterial;
-}
-
-/** Five 初始化参数 */
-export declare interface FiveInitArgs {
+     * 观察点的全景资源加载完成
+     * @param panoIndex - 加载点位
+     */
+    textureLoaded(panoIndex: number, meta: (NetWorkMeta | null)[]): void;
     /**
-     * 外部传入的 `THREE.WebGLRenderer`。
-     * @description
-     * 如果需要使用 `scissor` 分割画布功能，则必须使用外部传入 renderer，
-     * 并且设置为 `preserveDrawingBuffer: false`。
-     * 如果设置了 `renderer`, 则 `preserveDrawingBuffer`
-     * `backgroundColor` `backgroundAlpha` `antialias`
-     * 均不再生效。
+     * webXR模式开始，webxr session完成坐标系矫正
      */
-    renderer?: THREE_2.WebGLRenderer;
+    webXRSessionStart(): void;
     /**
-     * 内部 `THREE.WebGLRenderer` 是否通过像素拷贝的方式绘制。
-     * @description
-     * 当你想做屏幕截图等要确定取得屏幕像素时，请设置为 `true`。
-     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
-     * @default `false`
+     * webXR模式结束,webxr session销毁
      */
-    preserveDrawingBuffer?: boolean;
+    webXRSessionEnd(): void;
     /**
-     * 输出画面的背景颜色。
-     * @description
-     * 通过数字类型传入。
-     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
-     * @default `0x181A1C`
-     * @example
-     * ```
-     * backgroundColor: 0xffffff // 白色
-     * backgroundColor: 0xff0000 // 红色
-     * ```
+     * axes代表控制杆，axes数组的0-1元素分别代表左控制器的左（-1）右（1）,左控制器的上（-1）下（1），axes数组的2-3元素同理
      */
-    backgroundColor?: number;
+    webXRControllerEvent(type: WebXRControllerType, key: WebXRControllerKey, params: WebXRControllerParams): void;
     /**
-     * 输出画面的背景透明度
-     * @description
-     * 通过数字类型传入。取值范围 [0-1]
-     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
-     * @default `1`
+     * xr控制器的Axes原始实时数据状态
      */
-    backgroundAlpha?: number;
+    webXRAxesUpdate(type: 'left' | 'right', param: WebXRAxesParams): void;
     /**
-     * 是否开启 `THREE.WebGLRenderer` 的抗锯齿功能
-     * @description
-     * 这个抗锯齿功能是 `WEBGL` 自带的抗锯齿，并不是类似 fxaa taa 等后处理方式，比较吃性能。
-     * 如果设置了参数 `renderer` 参数，则不生效，请对传入的 `renderer` 自行设置。
-     * @default `false`
+     * xr控制器的控制器射线更新
      */
-    antialias?: boolean;
+    webXRControllerRayUpdate(raycaster: {
+        leftRay?: THREE_2.Raycaster;
+        rightRay?: THREE_2.Raycaster;
+    }): void;
     /**
-     * 屏幕渲染区域
-     * @description
-     * 请确保设置了 `renderer` 参数，`scissor` 参数才可生效
-     * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
-     * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
-     * @example
-     * ```
-     * scissor: { left: 0.75, bottom: 0, width: 0.25, height: 1 }
-     * ```
+     * 准备加载 Work 数据
+     * @param input - 输入的 work
+     * @param work - 归一化的标准 work
+     * @param state - 加载时的姿态
      */
-    scissor?: Scissor;
+    willLoad(input: any, work: Work, state: Partial<State>): void;
     /**
-     * 是否自动播放。
-     * @description
-     * 播放即把内存中计算的内容渲染到画面上。play则是进行每帧播放。
-     * 如果 `play: false` 则不自动播放。屏幕不显示。
-     * 你还可以通过 `five.play()` `five.pause()` 的方式来控制播放。
-     * @default `true`
+     * 开始加载 Work 数据
+     * @param input - 输入的 work
+     * @param work - 归一化的标准 work
+     * @param state - 加载时的姿态
      */
-    play?: boolean;
+    load(input: any, work: Work, state: Partial<State>): void;
     /**
-     * 全景图的配置参数
-     * @description
-     * 可以动态对配置在 `work` 数据中的全景图片在 runtime 做 url 调整。
-     * 平衡加载时间和图片质量
+     * 加载完 Work 数据
+     * @param input - 输入的 work
+     * @param work - 归一化的标准 work
      */
-    imageOptions?: ImageOptions;
+    loaded(input: any, work: Work): void;
     /**
-     * 模型贴图的配置参数
-     * @description
-     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
-     * 平衡加载时间和图片质量
+     * 当目标 state 变化时
+     * @param state - 当前姿态状态
+     * @param userAction - 是否用户触发
      */
-    textureOptions?: TextureOptions;
+    stateChange(state: State, userAction: boolean): void;
     /**
-     * 是否按需渲染
-     * @description
-     * 按需渲染时，如果页面中的渲染有 `needsRender: true` 属性。或者 `five.needsRender: true` 时
-     * 才会重新渲染屏幕，降低无用渲染产生的消耗。
-     * @default `true`
+     * 当前实时 state 变化时
+     * @param state - 当前姿态状态
+     * @param userAction - 是否用户触发
      */
-    onlyRenderIfNeeds?: boolean;
+    currentStateChange(state: State, userAction: boolean): void;
     /**
-     * 最高 fps 限制
-     * @description
-     * 如果为 `false`, 则不限制。最好也就是屏幕刷新率，不会再高了。
-     * @default `false`
+     * 当 setState 方法被调用
+     * @param state - 当前姿态状态
      */
-    maxFps?: number | false;
+    setState(state: State): void;
     /**
-     * 外挂视频对象。
-     * @description
-     * 当点位中有视频元素，则会使用。如果不传入也会外部新建，
-     * 加入传入的原因是，视频自动播放在不同浏览器或者 webview 中有不同的特性。
-     * 给予更多外部操作的空间。
+     * 当 state 被同步完成时
+     * @param state - 当前姿态状态
      */
-    videoInstance?: HTMLVideoElement;
-    /** 全景图游走模式下的特定参数 */
-    panorama?: ControllerCustomInitTypes["Panorama"];
-    /** 模型游走模式下的特定参数 */
-    model?: ControllerCustomInitTypes["Model"];
-    /** 模型查看模式下的特定参数 */
-    floorplan?: ControllerCustomInitTypes["Floorplan"];
-    /** 户型图模式下的特定参数 */
-    topview?: ControllerCustomInitTypes["Topview"];
-    /** 地图模式下的特定参数 */
-    mapview?: ControllerCustomInitTypes["Mapview"];
-    /** 深度图游走模式下的特定参数 */
-    depthPanorama?: ControllerCustomInitTypes["DepthPanorama"];
-    /** VR眼镜模式下的特定参数 */
-    vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
-    /** XR眼镜模式下的特定参数 */
-    xrPanorama?: ControllerCustomInitTypes["XRPanorama"];
+    stateSynced(state: State): void;
     /**
-     * 模式间切换时的过度动画时间
-     * @description
-     * 单位毫秒
-     * @default `800`
+     * 模型开始加载
+     * @param workModel - 归一化的标准 work 中的 model 值
      */
-    modeChangeDuration?: number;
+    modelWillLoad(workModel: WorkModel): void;
     /**
-     * 插件定义
-     * @description
-     * 详见插件部分。
+     * 模型加载错误
+     * @param error - 错误对象
+     * @param model - 加载完的 model
      */
-    plugins?: (FivePlugin<void> | FivePluginInit<FivePlugin<any, any>> | FivePluginInit<FivePlugin<void, any>>)[];
+    modelLoadError(error: Error, model: Model): void;
     /**
-     * 是否展示 powered by 如视
+     * 模型加载完成
+     * @param models - 加载完的 model
      */
-    poweredByRealsee?: boolean;
+    modelLoaded(model: Model): void;
     /**
-     * 是否使用webgl2渲染执行环境, 默认值 false
+     * 模型楼层切换
+     * @param shownFloor - 模型楼层
      */
-    webgl2?: boolean;
+    modelShownFloorChange(shownFloor: number | null, floorLength: number): void;
     /**
-     * 是否开启模型裁切
+     * 渲染循环
+     * @param rendered - 是否渲染了
      */
-    localClippingEnabled?: boolean;
+    renderFrame(rendered: boolean): void;
     /**
-     * 请求代理
-     * @param url - 发起的请求
-     * @returns 返回的请求
+     * 意图要切换到某个模态， 可以通过 return false 阻止
+     * @param mode - 意图要切换到的模态
+     * @param prevMode - 当前模态
+     * @returns 可以通过 return false 阻止
      */
-    requestProxy?(url: string): string | Promise<string>;
+    wantsChangeMode(mode: Mode, prevMode: Mode): void | false;
     /**
-     * 模型lod相关的配置，maxDepth为加载的最大深度
+     * 模态切换完成
+     * @param mode - 切换到的模态
+     * @param prevMode - 上本质是一个模态
+     * @param panoIndex - 初始化动画结束后的点位下标
+     * @param toPose - 初始化动画结束后的状态
+     * @param userAction - 是否用户触发
      */
-    modelLod?: {
-        maxDepth?: number;
-    };
-}
-
-/**
- * Five 插件
- * [[include:plugins.md]]
- * @template Parameters - 插件参数, 没有参数则为 void
- * @template Returns - 如果有参数则插件暴露的 api，没有参数则不传
- */
-export declare type FivePlugin<Parameters = void, Returns = void> = Parameters extends void ? ((five: Five) => Returns) : ((five: Five, parameters: Parameters) => Returns);
-
-/**
- * 获取插件在Five中的初始化结构
- * @template T - Five 插件
- */
-export declare type FivePluginInit<T extends FivePlugin<any, any>> = Parameters<T>[1] extends undefined ? [
-Plugin: T,
-instanceName: null | string
-] : [
-Plugin: T,
-instanceName: null | string,
-parameters: Parameters<T>[1]
-];
-
-/**
- * 获取插件暴露的 api
- * @template T - Five 插件
- */
-export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
-
-export declare interface FloorplanControllerCustomInitArgs {
-    /** 默认俯仰角 */
-    defaultLatitude?: number;
-    /** 最大俯仰角 */
-    maxLatitude?: number;
-    /** 最小俯仰角 */
-    minLatitude?: number;
-    /** 默认相机可视角度（垂直），可作为 `zoom` */
-    defaultFov?: number;
-    /** 最大相机可视角度 */
-    maxFov?: number;
-    /** 最小相机可视角度 */
-    minFov?: number;
-    /** 鼠标焦点环自定义创建器 */
-    intersectMeshCreator?: () => IntersectMeshInterface;
-}
-
-export declare type GestureTypes = "pan" | "tap" | "pinch" | "press" | "mouseWheel";
-
-export declare function getViewportScale(): number;
-
-/**
- * 图片参数
- */
-export declare interface ImageOptions {
+    modeChange(mode: Mode, prevMode: Mode, panoIndex: number, toPose: Pose, userAction: boolean): void;
     /**
-     * url 地址转化
-     * @param url - 原始地址
-     * @param options - 当前地址参数
-     * @returns 转化后地址
+     * 帮助元素显应的变换
+     * @param visible - 帮助元素的是否开启
      */
-    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];
-    };
-}
+    helpersVisibleChange(visible: boolean): void;
+    /**
+     * 网络资源分析
+     * @param source - 资源地址
+     * @param state - 状态
+     * @param detail - 详情
+     */
+    network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
+};
 
-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 function loadAt3d(url: string, options: {
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    textureArray?: string[];
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
 
-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 function loadB3dm(url: string, options: {
+    upAxis: 'X' | 'Y' | 'Z';
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
 
-export declare interface Intersection {
-    /** 焦点坐标 */
-    point: THREE.Vector3;
-    /** 焦点面片 */
-    face?: {
-        normal: THREE.Vector3;
-    } | null;
-    /** 焦点距离 */
-    distance: number;
-}
+export declare function loadDome(url: string, options: {
+    textureOptions: TextureOptions;
+    textureBaseUri?: string;
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
 
-export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
-    private ringMesh;
-    constructor();
-    dispose(): void;
-}
+export declare function loadDomez(url: string, options: {
+    textureOptions: TextureOptions;
+    textureBaseUri?: string;
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
 
-/**
- * 地面提示点位接口
- */
-export declare interface IntersectMeshInterface extends THREE_2.Object3D {
-    dispose(): void;
-}
+export declare function loadPbm(url: string, options: {
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    textureArray?: string[];
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
+
+export declare function loadPnts(url: string, options: {
+    fetcher: Fetcher;
+    computeBoundingBox?: boolean;
+}): Promise<ParsedResultType>;
 
 export declare type LooseWork = {
     work_code?: string;
@@ -1511,6 +1704,7 @@ export declare type LooseWorkPanorama = {
         back: string;
     };
     tiles?: number[];
+    tile_size?: number[];
 };
 
 export declare type LooseWorkVideo = {
@@ -1519,24 +1713,14 @@ export declare type LooseWorkVideo = {
     size: number[];
 };
 
-export declare type LooseWorkWithExtrinsics = {
+export declare type LooseWorkWithExtrinsics = ParseWorkOptions & {
+    /** work 数据 */
     work: LooseWork;
-    debug?: boolean;
-    /** 位姿 */
-    transform?: number[];
-    /** 可视区域 */
-    viewerRequestVolume?: BoundingVolumeJson;
-    /** 模型显示最大细化层级 */
-    modelMaxLevelOfDetail?: number;
-    /** 模型最大内存缓存 */
-    modelMaxMemoryUsage?: number;
-    /** 模型网络最大请求并发数 */
-    modelMaxRequests?: number;
-    /** 模型屏幕空间误差计算最大值 */
-    modelMaxScreenSpaceError?: number;
 };
 
 export declare interface MapviewControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 默认相机距离 */
@@ -1545,6 +1729,8 @@ export declare interface MapviewControllerCustomInitArgs {
     maxLatitude?: number;
     /** 最小俯仰角 */
     minLatitude?: number;
+    /** cameraType */
+    cameraType?: "perspective" | "orthographic" | "auto";
     /** 鼠标焦点环自定义创建器 */
     intersectMeshCreator?: () => IntersectMeshInterface;
 }
@@ -1558,7 +1744,6 @@ export declare type Mirror<T extends string> = Record<T, T>;
  * - **Floorplan**: 模型查看模式
  * - **Topview**: 户型图模式
  * - **Mapview**: 地图模式
- * - **DepthPanorama**: 深度图游走模式
  * - **VRPanorama**: VR眼镜模式
  */
 export declare type Mode = 
@@ -1574,11 +1759,14 @@ export declare type Mode =
 "VRPanorama" | 
 /** 模型游走模式 */
 "Model" | 
-/** 深度图游走模式 */
-"DepthPanorama" | 
 /** XR眼镜模式*/
 "XRPanorama";
 
+export declare interface ModeChangeEvent extends StateEvent {
+    prevMode: Mode;
+    mode: Mode;
+}
+
 /**
  * Five 模型
  * @description
@@ -1591,56 +1779,51 @@ export declare class Model extends THREE_2.Object3D {
     /** work */
     work: Work | null;
     /** 模型的不同图层 */
-    viewLayers: {
-        name: string;
-        type: string;
-        upAxis: string;
-        coordinates: string;
-        scene: Tile3DModel;
-    }[];
+    viewLayers: ModelViewLayer[];
     onError: (error: Error) => void;
     onShownFloorChange: (floorIndex: number | null) => void;
+    onLoad: () => void;
     /** 外接盒子的大小 */
     bounding: THREE_2.Box3;
-    /** 当前显示的楼层 */
-    shownFloor: number | null;
-    /** 楼层的数量 */
+    /** 所有楼层 */
     floorLength: number;
     /** 材质贴图参数 */
     textureOptions: TextureOptions;
+    autoRefine: boolean;
     /** 模型是否已经细化 */
     refined: boolean;
+    /** 模型细化进度 */
+    refineProgress: [number, number];
     /** 模型已经加载 */
     loaded: boolean;
-    /** 当前样式参数 */
-    materialVersion: string;
-    private _materialValues;
-    private _materialVersionMap;
-    private _floorIndex;
-    private _clippers;
-    /** 样式缓存 */
-    private cache;
+    /** 是否更新 */
     needsRender: boolean;
+    /** 缓存相机 */
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    /** 当前样式参数 */
+    materialVersion: number;
+    private materialParameters;
     private disposed;
     constructor(options?: {
         onError?: (error: Error) => void;
         onShownFloorChange?: (floorIndex: number | null) => void;
+        onLoad?: () => void;
     });
     get empty(): boolean;
     /** 获取材质参数 */
-    getMaterial(): ModelMaterialValues;
+    getMaterial(): PBMParameters;
     /** 设置材质参数 */
-    setMaterial(values: Partial<ModelMaterialValues>): void;
+    setMaterial(values: Partial<PBMParameters>): void;
     /**
      * 当前显示的楼层
      */
-    get shownfloor(): PBMParameters['floorIndex'] | null;
-    set shownfloor(floorIndex: PBMParameters['floorIndex'] | null);
+    get shownFloorIndex(): PBMParameters['shownFloorIndex'];
+    set shownFloorIndex(floorIndex: PBMParameters['shownFloorIndex']);
     /**
-     * 裁切
+     * 当前显示的楼层
      */
-    get clippers(): PBMParameters['clippers'];
-    set clippers(clippers: PBMParameters['clippers']);
+    get shownFloor(): number | null;
+    set shownFloor(floor: number | null);
     /**
      * 显示某楼层
      * @example
@@ -1649,7 +1832,12 @@ export declare class Model extends THREE_2.Object3D {
      * model.show(1) //显示第一楼层
      * ```
      */
-    show(floorIndex?: number | null): void;
+    show(floor?: number | null): void;
+    /**
+     * 裁切
+     */
+    get clippers(): PBMParameters['clippers'];
+    set clippers(clippers: PBMParameters['clippers']);
     /**
      * 获取模型边界线
      * @param sphere - 获取区域
@@ -1663,16 +1851,32 @@ export declare class Model extends THREE_2.Object3D {
      * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
      * @returns 返回碰撞
      */
-    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    intersectRaycaster(raycaster: THREE_2.Raycaster, floor?: undefined | null | number, sortByDistance?: boolean): Intersection[];
     /**
      * 加载模型
      * @param work - work 的
      * @param imageOptions - 图片参数
      */
     load(work: Work, options?: {
-        networkSubscribe?: NetworkSubscribe;
-        requestProxy?: (url: string) => string | Promise<string>;
         textureOptions?: TextureOptions;
+        "3d-tiles"?: {
+            /** 调试模式 */
+            debug?: boolean;
+            /** 显示图层 */
+            showLayers?: boolean | string[];
+            /** 可观测区域 */
+            viewerRequestVolume?: BoundingVolume;
+            /** 模型显示最小细化层级 */
+            minLevelOfDetail?: number;
+            /** 模型显示最大细化层级 */
+            maxLevelOfDetail?: number;
+            /** 模型最大内存缓存 */
+            maxMemoryUsage?: number;
+            /** 模型网络最大请求并发数 */
+            maxRequests?: number;
+            /** 模型屏幕空间误差计算最大值 */
+            maxScreenSpaceError?: number;
+        };
     }): Promise<void>;
     update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
     /**
@@ -1686,23 +1890,88 @@ export declare class Model extends THREE_2.Object3D {
 export declare interface ModelControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
 }
 
-export declare interface ModelLodOptions {
-    maxDepth?: number;
+export declare interface ModelEvent extends BaseEvent {
+    model: Model;
+    work: Work;
+    error: Error | null;
 }
 
-export declare type ModelMaterialValues = Pick<PBMParameters, 'pano0' | 'pano1' | 'modelAlpha' | 'progress' | 'useBlackTransition' | 'opacity' | 'constantColor' | 'useEDL' | 'pointShape' | 'pointColorType' | 'pointSizeType' | 'pointSize' | 'pointMinSize' | 'pointMaxSize' | 'pointSizeAdaptiveScale' | 'gradientTexture'>;
+export declare type ModelMaterialValues = Omit<PBMParameters, 'clippers' | 'shownFloorIndex'>;
 
 export declare type Models = Model[] & {
     needsRender: boolean;
+    /** 包围盒 */
     bounding: THREE_2.Box3;
+    /** 是否家在完成 */
     loaded: boolean;
+    /** 是否细化完成 */
     refined: boolean;
+    /** 细化成都 */
+    refineProgress: [number, number];
+    materialVersion: number;
+    /** 缓存相机 */
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    /** 是否自动更新模型 */
+    autoUpdate: boolean;
+    /**
+     * 计算模型射线碰撞检测
+     * @param raycaster - THREE 射线对象
+     * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
+     * @returns 返回碰撞
+     */
     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 class ModelViewLayer {
+    readonly scene: Tile3DModel;
+    readonly error: Error | null;
+    constructor(scene: Tile3DModel, error: Error | null);
+    get tileset(): Tileset;
+    get name(): string;
+    get type(): "point_cloud" | "mesh";
+    get upAxis(): string;
+    get groundHeight(): number;
+    get model(): Model;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.localToLla(new THREE.Vector()) 替代
+     */
+    get coordinates(): string;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.coordinateTransform 替代
+     */
+    getTransformMatrix4(target?: THREE_2.Matrix4): THREE_2.Matrix4;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.llaToWorld 替代
+     */
+    coordinatesToWorldPoint(coordinates: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    }): THREE_2.Vector3;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.llaToWorld 替代
+     */
+    worldPointToCoordinates(point: THREE_2.Vector3): {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+}
+
 export declare interface MotionKeyframe<K extends string> {
     progress: number;
     value: MotionValue<K>;
@@ -1711,21 +1980,27 @@ export declare interface MotionKeyframe<K extends string> {
 
 export declare type MotionValue<K extends string> = Record<K, number>;
 
+/**
+ * 动画模式
+ * @description
+ * - `fly` 通过相机移动方式变化
+ * - `instant` 直接变化
+ * - `fade` 通过渐变方式变化
+ * - `montage` 通过渐变穿插到黑屏方式变化
+ * - `spread` 通过扩散方式变化
+ * - `zoomin` 通过放大变化
+ * - `zoomout` 通过缩小变化
+ */
+export declare type MovePanoEffect = "fly" | "instant" | "fade" | "montage" | "spread" | "zoomin" | "zoomout";
+
 /**
  * 点位移动参数
  */
-export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
-    /** 是否通过初始化参数限制 fov, latitude */
-    limit?: boolean;
+export declare interface MovePanoOptions extends Partial<Omit<State, "offset" | 'distance' | 'mode'>> {
     /**
      * 动画模式
-     * @description
-     * - `fly` 通过相机移动方式变化
-     * - `fade` 通过渐变方式变化
-     * - `montage` 通过渐变穿插到黑屏方式变化
-     * - `instant` 通过插入黑屏方式变化
      */
-    effect?: "fly" | "fade" | "montage" | "instant";
+    effect?: MovePanoEffect;
     /**
      * 运动耗时
      * @description
@@ -1734,12 +2009,10 @@ export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
      * - `不传或者null` 通过距离和速度（速度为five初始化设置）
      */
     duration?: number | ((distance: number, speed: number) => number) | string | null;
-    /** 运动曲线函数 */
-    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
@@ -1751,6 +2024,18 @@ export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
     moveCancelCallback?: () => void;
 }
 
+export declare class NetworkAbortError extends Error {
+    constructor(source: string, type: NetworkType);
+}
+
+export declare type NetworkError = NetworkResponseError | NetworkAbortError | NetworkTimeoutError | NetworkFirbiddenError;
+
+export declare type NetworkErrorCallback = (error: NetworkError) => void;
+
+export declare class NetworkFirbiddenError extends Error {
+    constructor(source: string, type: NetworkType, reason: string);
+}
+
 export declare type NetWorkMeta = {
     origin: string;
     source: string;
@@ -1774,11 +2059,25 @@ export declare interface NetworkOptions {
     allowHosts?: string[];
 }
 
+export declare type NetworkProgressCallback = (percent: number) => void;
+
+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;
 };
 
+export declare class NetworkResponseError extends Error {
+    httpStatus: number;
+    constructor(source: string, type: NetworkType, status: number);
+}
+
 export declare type NetworkState = "ok" | "preload" | "error" | "proxy-error" | "timeout" | "forbidden";
 
 export declare class NetworkSubscribe extends Subscribe<{
@@ -1786,8 +2085,23 @@ export declare class NetworkSubscribe extends Subscribe<{
 }> {
 }
 
+export declare type NetworkSuccessCallback<T = any> = (response: NetworkResponse<T>) => void;
+
+export declare class NetworkTimeoutError extends Error {
+    constructor(source: string, type: NetworkType, timeout: number);
+}
+
 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;
@@ -1924,6 +2238,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;
@@ -1935,7 +2262,7 @@ export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeCo
      */
     panoTapTriggerRadius?: number;
     /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: (panoId: WorkPanoId) => PanoCircleMeshInterface;
+    panoCircleMeshCreator?: (pano: Pano) => PanoCircleMeshInterface;
     /**
      * 全景瓦片登记
      * @param fov - 当前 fov
@@ -1970,6 +2297,23 @@ 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;
+}
+
+export declare type ParsedResultType = {
+    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb';
+    byteLength: number;
+    uri: string;
+    object: THREE_2.Object3D;
+    dispose: () => void;
+};
+
 /**
  * 解析 Work 数据
  * @param obj - work 数据，从如数开发者平台获取
@@ -1979,26 +2323,22 @@ export declare interface PanoramaLikeControllerCustomInitArgs {
 export declare function parseWork(obj: Work | LooseWork | string | any, options?: ParseWorkOptions): Work;
 
 export declare type ParseWorkOptions = {
+    /** 位姿 */
+    transform?: THREE_2.Matrix4 | number[];
+    /** 重置 WorkCode */
+    workCode?: string | ((input: any) => string);
     /** 重写资源前缀 */
     baseURL?: string;
     /** 资源地址使用短地址 */
     shortPath?: boolean;
     /** 资源使用 jsonp 方式发布 */
     jsonp?: boolean;
-    /** 调试 */
-    debug?: boolean;
-    /** 位姿 */
-    transform?: THREE_2.Matrix4 | number[];
-    /** 可视区域 */
-    viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
-    /** 模型显示最大细化层级 */
-    modelMaxLevelOfDetail?: number;
-    /** 模型最大内存缓存 */
-    modelMaxMemoryUsage?: number;
-    /** 模型网络最大请求并发数 */
-    modelMaxRequests?: number;
-    /** 模型屏幕空间误差计算最大值 */
-    modelMaxScreenSpaceError?: number;
+    traverseResource?: (resource: {
+        origin: string;
+        absolute: string;
+        relative: string;
+        type: "panorama" | "texture" | "model";
+    }) => void;
 };
 
 /** PBM 模型组 */
@@ -2008,83 +2348,73 @@ export declare class PBMContainer extends THREE_2.Group {
     needsRender: boolean;
     /** 当前样式参数 */
     materialParameters: PBMParameters;
-    cache: PBMMaterialReferenceCache;
     constructor();
     /** 获取材质参数 */
     getMaterial(): PBMParameters;
     /** 设置材质参数 */
     setMaterial(parameters: Partial<PBMParameters>): void;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
-    /** 析构材质 */
-    dispose(): void;
 }
 
 /** PBM 模型组 */
 export declare class PBMGroup extends THREE_2.Group {
-    needsRender: boolean;
-}
-
-export declare class PBMMaterialReferenceCache {
-    cache: Record<string, {
-        count: number;
-        value: any;
-        dispose: () => void;
-    }>;
-    clear(): void;
-    get<T>(key: string, create: () => {
-        value: T;
-        dispose: () => void;
-    }): T;
 }
 
 /** PBM 对象 */
 export declare class PBMMesh extends THREE_2.Mesh<THREE_2.BufferGeometry, PBMMeshMaterial[]> {
-    /** 是否需要更新按需渲染 */
-    needsRender: boolean;
+    model?: Model;
+    constructor(geometry: THREE_2.BufferGeometry, materials: PBMMeshMaterial[]);
 }
 
 /** PBM 材质 */
 export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
     /** 更新版本 */
-    pbmMaterialParametersVersion: number;
+    syncModelVersion?: string;
     /** 起始点 */
-    pano0: PBMPanoPicture | null;
+    pano0: PBMParameters['pano0'];
     /** 结束点 */
-    pano1: PBMPanoPicture | null;
+    pano1: PBMParameters['pano1'];
     /** 模型贴图和全景图的混合程度 [0-1] */
-    modelAlpha: number;
+    modelAlpha: PBMParameters['modelAlpha'];
     /** 全景图混合程度 [0-1] */
-    progress: number;
-    /** 全景图通过过度黑色混合 */
-    useBlackTransition: boolean;
+    progress: PBMParameters['progress'];
+    /** 全景图过度混合 */
+    transition: PBMParameters['transition'];
     /** 模型透明度 */
-    opacity: number;
+    opacity: PBMParameters['opacity'];
     /** 模型颜色*/
-    constantColor: THREE_2.Vector3 | null;
+    constantColor: PBMParameters['constantColor'];
     /** 楼层参数*/
-    floorIndex: number;
+    shownFloorIndex: PBMParameters['shownFloorIndex'];
     /** 对外模型裁切参数*/
-    clippers: ClipperParameter[] | null;
+    clippers: PBMParameters['clippers'];
     /** edl*/
-    useEDL: boolean;
+    useEDL: PBMParameters['useEDL'];
+    /** hq*/
+    useHQWeight: PBMParameters['useHQWeight'];
+    /** HQDepthMask*/
+    useHQDepth: PBMParameters['useHQDepth'];
     /** 点云着色方式*/
-    pointColorType: PBMPointColorType;
+    pointColor: PBMParameters['pointColor'];
     /** 点云大小绘制方式*/
-    pointSizeType: PBMPointSizeType;
+    pointSize: PBMParameters['pointSize'];
     /** 点云形状*/
-    pointShape: PBMPointShapeType;
+    pointShape: PBMParameters['pointShape'];
     /** 点云基础大小*/
-    pointSize: number;
-    /** 自适应点云大小因子*/
-    pointSizeAdaptiveScale: number;
-    /** 点云最大尺寸*/
-    pointMinSize: number;
-    /** 点云最小尺寸*/
-    pointMaxSize: number;
+    pointScale: PBMParameters['pointScale'];
+    /** 点云背面绘制方式*/
+    pointBack: PBMParameters['pointBack'];
+    /** 点云像素最小值*/
+    pointMinPixel: PBMParameters['pointMinPixel'];
+    /** 点云像素最大值*/
+    pointMaxPixel: PBMParameters['pointMaxPixel'];
     /** 高程彩色图*/
-    gradientTexture: THREE_2.Texture | null;
+    gradientTexture: PBMParameters['gradientTexture'];
+    /** 所属楼层*/
+    floor: number;
     constructor(parameters?: Partial<PBMParameters>);
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, cache: PBMMaterialReferenceCache): void;
+    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.Camera): void;
+    syncModel(model: Model): void;
 }
 
 export declare interface PBMPanoPicture {
@@ -2094,6 +2424,8 @@ export declare interface PBMPanoPicture {
     luminanceMap: null | THREE_2.CubeTexture | TileCubeTextureTarget;
     /** 起始点全景图变换矩阵 4x4 */
     matrix: THREE_2.Matrix4;
+    /** 缩放 */
+    zoom: number;
 }
 
 /** PBM 材质参数 */
@@ -2106,51 +2438,40 @@ export declare interface PBMParameters {
     modelAlpha: number;
     /** 全景图混合程度 [0-1] */
     progress: number;
-    /** 全景图通过过度黑色混合 */
-    useBlackTransition: boolean;
+    /** 全景图过度混合 */
+    transition: 'BLACK' | 'SPREAD' | 'FADE';
     /** 模型透明度 */
     opacity: number;
     /** 楼层参数*/
-    floorIndex: number;
+    shownFloorIndex: number;
     /** 模型裁切参数（工程侧调用）*/
     clippers: ClipperParameter[] | null;
     /** 模型颜色*/
     constantColor: THREE_2.Vector3 | null;
     /** 是否使用EDL*/
     useEDL: boolean;
+    /** 是否使用HQ*/
+    useHQWeight: boolean;
+    /** 是否使用HQ_DEPTH_MASK*/
+    useHQDepth: boolean;
     /** 点云形状*/
-    pointShape: PBMPointShapeType;
+    pointShape: 'SQUARE' | 'CIRCLE';
     /** 点云着色方式*/
-    pointColorType: PBMPointColorType;
+    pointColor: 'RGB' | 'ALTITUDE';
     /** 点云大小绘制方式*/
-    pointSizeType: PBMPointSizeType;
+    pointSize: 'FIXED' | 'ATTENUATION' | 'GEOMETRIC';
+    /** 点云背面绘制方式*/
+    pointBack: 'VISIBLE' | 'HIDDEN' | 'DARK';
     /** 点云基础大小*/
-    pointSize: number;
+    pointScale: number;
     /** 点云最大尺寸*/
-    pointMinSize: number;
+    pointMinPixel: number;
     /** 点云最小尺寸*/
-    pointMaxSize: number;
-    /** 自适应点云尺寸因子*/
-    pointSizeAdaptiveScale: number;
+    pointMaxPixel: number;
     /** 高程彩色图*/
     gradientTexture: THREE_2.Texture | null;
 }
 
-export declare enum PBMPointColorType {
-    RGB = "rgb",
-    ALTITUDE = "altitude"
-}
-
-export declare enum PBMPointShapeType {
-    SQUARE = "square",
-    CIRCLE = "circle"
-}
-
-export declare enum PBMPointSizeType {
-    FIXED = "fixed",
-    ADAPTIVE = "adaptive"
-}
-
 /**
  * 相机位姿
  * [[include: coordinate.md]]
@@ -2168,7 +2489,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", "xr.controller.update"];
 
 export declare class RegionBoundingVolume implements BoundingVolume {
     type: "regin";
@@ -2187,8 +2510,9 @@ export declare class RegionBoundingVolume implements BoundingVolume {
     toGeometry(): THREE_2.BufferGeometry;
     applyMatrix4(matrix: THREE_2.Matrix4): this;
     getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
-    distanceTo(point: THREE_2.Vector3): number;
-    distanceSquaredTo(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
     intersectRay(ray: THREE_2.Ray): boolean;
 }
@@ -2197,6 +2521,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;
 };
@@ -2275,10 +2616,11 @@ export declare class SphereBoundingVolume implements BoundingVolume {
     toGeometry(): THREE_2.BufferGeometry;
     applyMatrix4(matrix: THREE_2.Matrix4): this;
     getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
-    distanceSquaredTo(point: THREE_2.Vector3): number;
-    distanceTo(point: THREE_2.Vector3): number;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
-    intersectRay(ray: THREE_2.Ray): boolean;
+    intersectRay(ray: THREE_2.Ray, far?: number): boolean;
 }
 
 export declare type SphereBoundingVolumeJson = {
@@ -2297,10 +2639,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;
 }
 
 /**
@@ -2392,7 +2739,7 @@ export declare namespace SubscribeMixinType {
 }
 
 export declare class TextureLoader {
-    loadTexture(source: string, options?: {
+    loadTexture(source: string, options: {
         imageURL?: {
             transform?: (source: string, options: ImageURLOptions) => string;
             options?: ImageURLOptions;
@@ -2401,11 +2748,14 @@ export declare class TextureLoader {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         wrapS?: THREE_2.Wrapping;
         wrapT?: THREE_2.Wrapping;
         maxSize?: THREE_2.Vector2;
         viaAjax?: boolean;
-    } & NetworkOptions, onLoad?: (response: NetworkResponse<THREE_2.Texture>) => void, onError?: (error: Error) => void, onProgress?: (percent: number) => void, renderer?: THREE_2.WebGLRenderer): Promise<NetworkResponse<THREE_2.Texture>>;
+        timeout?: number;
+        fetcher: Fetcher;
+    }, onLoad?: (response: NetworkResponse<THREE_2.Texture>) => void, onError?: (error: Error) => void, onProgress?: (percent: number) => void, renderer?: THREE_2.WebGLRenderer): Promise<NetworkResponse<THREE_2.Texture>>;
     loadCubeTexture(sources: WorkCubeImage, options: {
         imageURL?: {
             transform?: (source: string, options: ImageURLOptions) => string;
@@ -2414,12 +2764,14 @@ export declare class TextureLoader {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         wrapS?: THREE_2.Wrapping;
         wrapT?: THREE_2.Wrapping;
         viaAjax?: boolean;
-    } & NetworkOptions, onLoad: (response: NetworkResponse<THREE_2.CubeTexture, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<THREE_2.CubeTexture, NetWorkMeta[]>>;
+        timeout?: number;
+        fetcher: Fetcher;
+    }, onLoad: (response: NetworkResponse<THREE_2.CubeTexture, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<THREE_2.CubeTexture, NetWorkMeta[]>>;
     loadTiledCubeTexture(sources: WorkCubeImage, tileSources: WorkTile[], options: {
-        tileImageSize?: number;
         tileMaxLevel?: number;
         imageURL?: {
             transform?: (source: string, options: ImageURLOptions) => string;
@@ -2428,10 +2780,13 @@ export declare class TextureLoader {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         wrapS?: THREE_2.Wrapping;
         wrapT?: THREE_2.Wrapping;
         viaAjax?: boolean;
-    } & NetworkOptions, onLoad: (response: NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>>;
+        timeout?: number;
+        fetcher: Fetcher;
+    }, onLoad: (response: NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>>;
 }
 
 /**
@@ -2485,7 +2840,6 @@ export declare class Tile {
         requestedFrameNumber: number;
         touchedFrameNumber: number;
         selectionDepth: number;
-        centerZDepth: number;
         shouldRefine: boolean;
         distanceToCamera: number;
         screenSpaceError: number;
@@ -2511,57 +2865,95 @@ export declare class Tile {
 }
 
 export declare class Tile3DModel extends THREE_2.Object3D {
+    static DEFAULT_MIN_LEVEL_OF_DETAIL: number;
     static DEFAULT_MAX_LEVEL_OF_DETAIL: number;
     static DEFAULT_MAX_MEMORY_USAGE: number;
     static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
     static DEFAULT_MAX_REQUESTS: number;
-    workCode: string;
+    type: 'point_cloud' | 'mesh';
+    upAxis: string;
+    model: Model;
+    viewLayer?: ModelViewLayer;
+    search: string;
+    groundHeight: number | null;
+    coordinateTransform: {
+        localToEnuMatrix: THREE_2.Matrix4;
+        enuToLocalMatrix: THREE_2.Matrix4;
+        enuToEcefMatrix: THREE_2.Matrix4;
+        ecefToEnuMatrix: THREE_2.Matrix4;
+        viewToEcefMatrix: THREE_2.Matrix4;
+        ecefToViewMatrix: THREE_2.Matrix4;
+    };
     tileset: Tileset;
+    idle: boolean;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
     boundingBox: THREE_2.Box3;
     needsRefined: boolean;
     refined: boolean;
+    refineProgress: [number, number];
     loaded: boolean;
-    disposed: boolean;
     needsRender: boolean;
-    lastRefineTime: number;
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    private lastRefineTime;
+    private disposed;
     private nodeGroup;
     private debugBoundingGroup;
     private nodes;
     private debugBoundings;
     private unloadTileQueue;
-    constructor(workCode: string, tilesetHeader: TilesetHeader, options: Partial<Tile3DModelLoaderOptions>);
+    constructor(model: Model, tilesetHeader: TilesetHeader, options: Tile3DModelLoaderOptions);
     get debug(): boolean;
     set debug(value: boolean);
     get maxMemoryUsage(): number;
     set maxMemoryUsage(value: number);
-    get viewDistanceScale(): number;
-    set viewDistanceScale(value: number);
     get maxRequests(): number;
     set maxRequests(value: number);
     get maxScreenSpaceError(): number;
     set maxScreenSpaceError(value: number);
+    localToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
+    localToEcef(vector: THREE_2.Vector3): THREE_2.Vector3;
+    ecefToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
+    localToLla(vector: THREE_2.Vector3): THREE_2.Vector3;
+    llaToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
+    worldToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
+    worldToEcef(vector: THREE_2.Vector3): THREE_2.Vector3;
+    ecefToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
+    worldToLla(vector: THREE_2.Vector3): THREE_2.Vector3;
+    llaToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
     loadContent(tile: Tile, options: {
-        allowHosts?: string[];
-        requestProxy?: (url: string) => string | Promise<string>;
-        networkSubscribe?: NetworkSubscribe;
+        fetcher: Fetcher;
     }): Promise<boolean>;
-    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
     update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
     dispose(): void;
 }
 
 /** Advanced loader options */
 export declare interface Tile3DModelLoaderOptions {
+    name: string;
+    type: 'point_cloud' | 'mesh';
+    upAxis: string;
+    referer: string;
+    fetcher: Fetcher;
     resourcePath: string;
-    allowHosts?: string[];
-    requestProxy?: (url: string) => string | Promise<string>;
-    networkSubscribe?: NetworkSubscribe;
+    groundHeight: number | null;
+    coordinateTransform: {
+        localToEnuMatrix: THREE_2.Matrix4;
+        enuToLocalMatrix: THREE_2.Matrix4;
+        enuToEcefMatrix: THREE_2.Matrix4;
+        ecefToEnuMatrix: THREE_2.Matrix4;
+        viewToEcefMatrix: THREE_2.Matrix4;
+        ecefToViewMatrix: THREE_2.Matrix4;
+    };
+    search?: string;
     onError?: (error: Error) => void;
 }
 
 export declare type TileContentData = {
-    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm';
+    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb';
     byteLength: number;
     uri: string;
     object: TileNode;
@@ -2591,7 +2983,6 @@ export declare class TileCubeTextureTarget {
     private textures;
     constructor(baseCubeTexture: THREE_2.CubeTexture, tileTree: TileCubeTree, tileSources: WorkTile[], options: {
         textureSize: number;
-        tileImageSize: number;
         textureLoader: TextureLoader;
         imageURL?: {
             transform?: (source: string, options: ImageURLOptions) => string;
@@ -2600,9 +2991,12 @@ export declare class TileCubeTextureTarget {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         wrapS?: THREE_2.Wrapping;
         wrapT?: THREE_2.Wrapping;
-    } & NetworkOptions, renderer: THREE_2.WebGLRenderer);
+        timeout?: number;
+        fetcher: Fetcher;
+    }, renderer: THREE_2.WebGLRenderer);
     get cubeRenderTarget(): THREE_2.WebGLCubeRenderTarget | null;
     set cubeRenderTarget(cubeRenderTarget: THREE_2.WebGLCubeRenderTarget | null);
     private requestTile;
@@ -2632,11 +3026,10 @@ export declare interface TileHeader {
 }
 
 export declare class TileNode extends THREE_2.Group {
-    bvhTree: BVH | undefined;
-    objType: 'mesh' | 'points';
-    constructor(obj: THREE_2.Object3D, objType: 'mesh' | 'points');
-    buildBvhTree(): void;
-    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    private disposers;
+    constructor(obj: THREE_2.Object3D, objDisposer: () => void);
+    generateBvhTree(): Promise<void>;
+    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
     dispose(): void;
 }
 
@@ -2648,26 +3041,50 @@ export declare class Tileset {
     asset: {
         version: string;
         tilesetVersion: string;
-        gltfUpAxis: "X" | "Y" | "Z";
+        gltfUpAxis: "Y" | "Z";
+        overview?: {
+            imageFile: string;
+            worldFile: string;
+            imageWidth: number;
+            imageHeight: number;
+        };
+        [key: string]: any;
     };
     id: string;
+    referer: string;
     frameNumber: number;
     properties: Record<string, any>;
     options: TilesetOptions;
     root: Tile;
-    transfrom: THREE_2.Matrix4;
+    rootMeta: {
+        creationTime?: string;
+        upAxis?: string;
+        coordinate?: {
+            base_keyframe: number;
+            base_trajectory: number;
+            coordinate_system: string;
+            ground_height: number;
+            lon_lat_alt: [number, number, number];
+            pose_ecef_to_enu: number[];
+            pose_enu_to_ecef: number[];
+            version: number;
+        };
+    };
+    transform: THREE_2.Matrix4;
+    transformIsIdentity: boolean;
     geometricError: number;
-    traverser: TilesetTraverser;
+    private traverser;
     cache: TilesetCache;
     requestScheduler: RequestScheduler<string>;
     private memoryUsageInBytes;
     maxMemoryUsage: number;
-    viewDistanceScale: number;
     tiles: Map<string, Tile>;
     private pendingCount;
     constructor(id: string, header: TilesetHeader, options: TilesetOptions);
     get maxRequests(): number;
     set maxRequests(value: number);
+    get skipLevelOfDetail(): boolean;
+    set skipLevelOfDetail(value: boolean);
     get maxScreenSpaceError(): number;
     set maxScreenSpaceError(value: number);
     get selectedTiles(): Map<string, Tile>;
@@ -2676,11 +3093,7 @@ export declare class Tileset {
     reset(): void;
     /** Is the tileset loaded (update needs to have been called at least once) */
     isLoaded(): boolean;
-    /**
-     * The callback to post-process tiles after traversal procedure
-     * @param frameState - frame state for tile culling
-     */
-    private onTraversalEnd;
+    traverse(frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
     loadTile(tile: Tile): void;
     unloadTile(tile: Tile): void;
 }
@@ -2700,14 +3113,19 @@ export declare class TilesetCache {
 
 export declare type TilesetFrameState = {
     camera: {
+        type: "PerspectiveCamera" | "OrthographicCamera";
         position: THREE.Vector3;
         direction: THREE.Vector3;
         up: THREE.Vector3;
+        visible: boolean;
+        refine: boolean;
     };
     height: number;
+    pixelRatio: number;
     cullingVolume: CullingVolume;
     frameNumber: number;
     sseDenominator: number;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
 };
 
@@ -2715,21 +3133,40 @@ export declare interface TilesetHeader {
     asset: {
         version: string;
         tilesetVersion?: string;
-        gltfUpAxis?: "X" | "Y" | "Z";
+        gltfUpAxis?: "Y" | "Z";
+        overview?: {
+            imageFile: string;
+            worldFile: string;
+            imageWidth: number;
+            imageHeight: number;
+        };
+        [key: string]: any;
     };
     properties?: Record<string, any>;
     geometricError: number;
     root: TileHeader;
+    rootMeta?: {
+        creationTime?: string;
+        upAxis?: string;
+        coordinate?: {
+            base_keyframe: number;
+            base_trajectory: number;
+            coordinate_system: string;
+            ground_height: number;
+            lon_lat_alt: [number, number, number];
+            pose_ecef_to_enu: number[];
+            pose_enu_to_ecef: number[];
+            version: number;
+        };
+    };
 }
 
 export declare interface TilesetOptions {
+    referer?: string;
+    contentLoader: (tile: Tile) => Promise<boolean>;
     onTileLoad: (tile: Tile) => any;
     onTileUnload: (tile: Tile) => any;
     onTileError: (tile: Tile, error: Error) => any;
-    contentLoader: (tile: Tile) => Promise<boolean>;
-    allowHosts?: string[];
-    requestProxy?: (url: string) => string | Promise<string>;
-    networkSubscribe?: NetworkSubscribe;
 }
 
 export declare class TilesetTraverser {
@@ -2740,15 +3177,15 @@ export declare class TilesetTraverser {
     loadSiblings: boolean;
     skipLevelOfDetail: boolean;
     maxScreenSpaceError: number;
-    onTraversalEnd: (frameState: TilesetFrameState) => any;
     requestedTiles: Map<string, Tile>;
     selectedTiles: Map<string, Tile>;
     needsRefinedTiles: Map<string, Tile>;
     emptyTiles: Map<string, Tile>;
+    private _canSelectTile;
     private _traversalStack;
     private _emptyTraversalStack;
-    constructor(onTraversalEnd: (frameState: TilesetFrameState) => any);
-    traverse(root: Tile, frameState: TilesetFrameState): void;
+    constructor();
+    traverse(root: Tile, frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
     reset(): void;
     private executeTraversal;
     private updateChildTiles;
@@ -2779,26 +3216,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[];
     /** 过期时间 */
@@ -2811,8 +3258,19 @@ export declare class Work {
     observers: WorkObserver[];
     /** 数据签发人 */
     issuer: string;
-    /** 控制参数 */
-    options: WorkOptions;
+    /** 位姿修正 */
+    transform: THREE_2.Matrix4;
+    /**
+     * 控制参数
+     * @deprecated 通过 work.transform 替换
+     */
+    options: {
+        /**
+         * 位姿修正
+         * @deprecated 通过 work.transform 替换
+         */
+        transform: THREE_2.Matrix4;
+    };
     /** 原始数据 */
     raw: {
         works: string[];
@@ -2829,8 +3287,6 @@ export declare class Work {
     toJSON(): any;
 }
 
-export declare type WorkCode = string;
-
 export declare interface WorkCubeImage {
     /** 全景图 up */
     up: string;
@@ -2844,24 +3300,27 @@ export declare interface WorkCubeImage {
     front: string;
     /** 全景图 back */
     back: string;
+    /** 分辨率表 */
+    sizeList?: number[];
 }
 
 /** 全景图 */
 export declare interface WorkImage extends WorkCubeImage {
-    /** 深度图 */
-    depth?: string;
     /** 光照强度图 */
-    luminance?: WorkCubeImage;
+    luminance?: WorkCubeImage & {
+        tiles?: WorkTile[];
+    };
     /** 瓦片信息 */
     tiles?: WorkTile[];
 }
 
 /** 初始化位姿参数 */
 export declare interface WorkInitial {
+    work: Work;
     /** 模态 */
     mode?: Mode;
     /** 点位序号 */
-    panoId?: string;
+    panoIndex?: number;
     /** 相机水平角 */
     longitude?: number;
     /** 相机俯仰角 */
@@ -2899,12 +3358,18 @@ export declare interface WorkObserver {
     work: Work;
     /** 序号 */
     index: number;
+    /** 序号 */
+    panoIndex: number;
     /** 点位序号 */
-    panoId: WorkPanoId;
+    panoId: PanoId;
+    /** 点位序号 */
+    pano: Pano;
     /** 点位所在楼层 */
     floorIndex: number;
     /** 点位 derived_id */
     derivedId?: number;
+    /** 点位 derived_id_str */
+    derivedIdStr?: string;
     /** 点位是否激活可用 */
     active: boolean;
     /** 点位是否可加载 */
@@ -2914,9 +3379,13 @@ export declare interface WorkObserver {
     /** 点位视频 */
     video?: WorkVideo;
     /** 可以看到的相关点位序号 */
-    visibleIds: string[];
+    visibleNodes: number[];
+    /** 可以看到的相关点位序号 */
+    visibleIds: PanoId[];
     /** 可以连通的相关点位序号 */
-    accessibleIds: string[];
+    accessibleNodes: number[];
+    /** 可以看到的相关点位序号 */
+    accessibleIds: PanoId[];
     /** 点位和模型的地面坐标 */
     standingPosition: THREE_2.Vector3;
     /** 点位和模型的观察点坐标 */
@@ -2925,36 +3394,29 @@ export declare interface WorkObserver {
     quaternion: THREE_2.Quaternion;
 }
 
-export declare interface WorkOptions {
-    /** 调试 */
-    debug?: boolean;
-    /** 位姿修正 */
-    transform: THREE_2.Matrix4;
-    /** 可观测区域 */
-    viewerRequestVolume?: BoundingVolume;
-    /** 模型显示最大细化层级 */
-    modelMaxLevelOfDetail?: number;
-    /** 模型最大内存缓存 */
-    modelMaxMemoryUsage?: number;
-    /** 模型网络最大请求并发数 */
-    modelMaxRequests?: number;
-    /** 模型屏幕空间误差计算最大值 */
-    modelMaxScreenSpaceError?: number;
+export declare interface WorkResolvedObserver extends WorkObserver {
+    isResolved: true;
 }
 
-export declare type WorkPanoId = string;
-
 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;
+    scale: number;
     up: string;
     down: string;
     right: string;
@@ -2977,7 +3439,60 @@ export declare class XRButton {
     static createButton(onClickHook: () => void): HTMLAnchorElement | HTMLButtonElement;
 }
 
+export declare interface XRControllerEvent extends BaseEvent {
+    left: {
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
+        };
+        raycaster: THREE_2.Raycaster;
+        deltaTime: number;
+    };
+    right: {
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
+        };
+        raycaster: THREE_2.Raycaster;
+        deltaTime: number;
+    };
+    buttons: {
+        X: boolean;
+        Y: boolean;
+        LeftTrigger: boolean;
+        LeftPinch: boolean;
+        A: boolean;
+        B: boolean;
+        RightTrigger: boolean;
+        RightPinch: boolean;
+    };
+}
+
+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 { }