@realsee/five 5.0.0-alpha.131 → 5.0.0-alpha.135

package/five/index.d.ts

@@ -39,51 +39,6 @@ export declare class AnimationFrameLoop {
     disponse(): void;
 }
 
-declare interface B3DMMapping {
-    b3dm_base_url: string;
-    b3dm_url: Record<string, string>;
-}
-
-declare class BoundingSphere {
-    center: Vector3;
-    radius: number;
-    constructor(center?: number[], radius?: number);
-    fromCenterRadius(center: number[], radius: number): this;
-    fromCornerPoints(corner: number[], oppositeCorner: number[]): this;
-    equals(right: BoundingSphere): boolean;
-    clone(): BoundingSphere;
-    union(boundingSphere: BoundingSphere): BoundingSphere;
-    expand(point: number[]): this;
-    transform(transform: Matrix4): this;
-    distanceSquaredTo(point: number[]): number;
-    distanceTo(point: number[]): number;
-    intersectPlane(plane: Plane): number;
-}
-
-declare interface BoundingVolume {
-    /**
-     * Applies a 4x4 affine transformation matrix to a bounding sphere.
-     * @param sphere The bounding sphere to apply the transformation to.
-     * @param transform The transformation matrix to apply to the bounding sphere.
-     * @returns itself, i.e. the modified BoundingVolume.
-     */
-    transform(transform: readonly number[]): this;
-    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
-    distanceSquaredTo(point: readonly number[]): number;
-    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
-    distanceTo(point: readonly number[]): number;
-    /**
-     * Determines which side of a plane the oriented bounding box is located.
-     *
-     * @param plane The plane to test against.
-     * @returns
-     *  - `INTERSECTION.INSIDE` if the entire box is on the side of the plane the normal is pointing.
-     *  - `INTERSECTION.OUTSIDE` if the entire box is on the opposite side.
-     *  - `INTERSECTION.INTERSECTING` if the box intersects the plane.
-     */
-    intersectPlane(plane: Plane): number;
-}
-
 export declare class BVH {
     trianglesArray?: Float32Array;
     offsetArray?: Uint32Array;
@@ -140,13 +95,6 @@ export declare class BVHVector3 {
     clone(): BVHVector3;
 }
 
-declare class CacheNode<T> {
-    item: T;
-    previous: CacheNode<T> | null;
-    next: CacheNode<T> | null;
-    constructor(item: T, previous: CacheNode<T> | null, next: CacheNode<T> | null);
-}
-
 /** Five 相机 */
 export declare class Camera extends THREE_2.PerspectiveCamera {
     /** 相机姿态 */
@@ -465,20 +413,6 @@ export declare type ControllerEventTypes = {
     error(error: Error): void;
 };
 
-declare class CullingVolume {
-    static get MASK_OUTSIDE(): number;
-    static get MASK_INSIDE(): number;
-    static get MASK_INDETERMINATE(): number;
-    planes: Plane[];
-    constructor(planes?: Plane[]);
-    fromBoundingSphere(boundingSphere: {
-        center: Vector3;
-        radius: number;
-    }): this;
-    computeVisibility(boundingVolume: BoundingVolume): number;
-    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
-}
-
 /**
  * URL 地址的转换
  * @param source - url 原地址
@@ -641,8 +575,9 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
      * @param prevMode - 上本质是一个模态
      * @param panoIndex - 初始化动画结束后的点位下标
      * @param toPose - 初始化动画结束后的状态
+     * @param userAction - 是否用户触发
      */
-    modeChange(mode: Mode, prevMode: Mode, panoIndex: number, toPose: Pose): void;
+    modeChange(mode: Mode, prevMode: Mode, panoIndex: number, toPose: Pose, userAction: boolean): void;
     /**
      * 帮助元素显应的变换
      * @param visible - 帮助元素的是否开启
@@ -1037,8 +972,17 @@ export declare class Five extends Subscribe<EventTypes> {
     setState(state: Partial<State>, immediately?: boolean, userAction?: boolean): void;
     aroundScissor(callback: () => void): void;
     private syncState;
+    /**
+     * 当前页面静态
+     */
     ready(): Promise<void>;
+    /**
+     * 请求全屏
+     */
     requestFullscreen(): void;
+    /**
+     * 退出全屏
+     */
     exitFullscreen(): void;
     private throwError;
     private loadModel;
@@ -1211,7 +1155,7 @@ export declare interface FiveInitArgs {
     webgl2?: boolean;
     /**
      * 请求代理
-     * @param url 发起的请求
+     * @param url - 发起的请求
      * @returns 返回的请求
      */
     requestProxy?(url: string): string;
@@ -1244,11 +1188,6 @@ parameters: Parameters<T>[1]
  */
 export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
 
-declare interface FloorInfo {
-    ground: number;
-    height: number;
-}
-
 export declare interface FloorplanControllerCustomInitArgs {
     /** 默认偏航角 */
     defaultLongitude?: number;
@@ -1266,18 +1205,6 @@ export declare interface FloorplanControllerCustomInitArgs {
     minFov?: number;
 }
 
-declare type FrameState = {
-    camera: {
-        position: number[];
-        direction: number[];
-        up: number[];
-    };
-    height: number;
-    cullingVolume: CullingVolume;
-    frameNumber: number;
-    sseDenominator: number;
-};
-
 export declare type GestureTypes = "pan" | "tap" | "pinch" | "press" | "mouseWheel";
 
 export declare function getViewportScale(): number;
@@ -1395,21 +1322,6 @@ export declare class LegacyPanoCircleMesh extends THREE_2.Object3D implements Pa
     dispose(): void;
 }
 
-/** Advanced loader options */
-declare interface LoaderOptions {
-    updateInterval: number;
-    maxMemoryUsage: number;
-    maxScreenSpaceError: number;
-    viewDistanceScale: number;
-    throttleRequests: boolean;
-    maxRequests: number;
-    onNodeCreated: (node: PBMGroup) => void;
-    allowHosts?: string[];
-    requestProxy?: (url: string) => string;
-    networkSubscribe?: NetworkSubscribe;
-    maxDepth?: number;
-}
-
 export declare type LooseWork = {
     bvh?: boolean;
     modelAsync?: boolean;
@@ -1484,48 +1396,6 @@ export declare type LooseWorkVideo = {
     size: number[];
 };
 
-declare class ManagedArray<T> {
-    private map;
-    private array;
-    private _length;
-    constructor();
-    /**
-     * Gets or sets the length of the array.
-     * If the set length is greater than the length of the internal array, the internal array is resized.
-     *
-     * @memberof ManagedArray.prototype
-     * @type Number
-     */
-    get length(): number;
-    /**
-     * Gets the element at an index.
-     * @param { Number } index The index to get.
-     */
-    get(index: number): T;
-    /**
-     * Sets the element at an index. Resizes the array if index is greater than the length of the array.
-     *
-     * @param {Number} index The index to set.
-     * @param {*} element The element to set at index.
-     */
-    set(index: number, element: T): void;
-    delete(element: T): void;
-    /**
-     * Push an element into the array.
-     *
-     * @param {*} element The element to push.
-     */
-    push(element: T): void;
-    /**
-     * Pop an element from the array.
-     *
-     * @returns {*} The last element in the array.
-     */
-    pop(): T;
-    reset(): void;
-    find(target: T): boolean;
-}
-
 export declare interface MapviewControllerCustomInitArgs {
     /** 默认偏航角 */
     defaultLongitude?: number;
@@ -1800,23 +1670,6 @@ export declare class NetworkSubscribe extends Subscribe<{
 
 export declare type NetworkType = "XMLHttpRequest" | "Script" | "Image" | "Link";
 
-declare class OrientedBoundingBox {
-    center: Vector3;
-    halfAxes: Matrix3;
-    constructor(center?: number[], halfAxes?: number[]);
-    get halfSize(): number[];
-    get quaternion(): Quaternion;
-    fromCenterHalfSizeQuaternion(center: number[], halfSize: number[], quaternion: number[]): this;
-    clone(): OrientedBoundingBox;
-    equals(right: OrientedBoundingBox): boolean;
-    getBoundingSphere(result?: BoundingSphere): BoundingSphere;
-    intersectPlane(plane: Plane): number;
-    distanceTo(point: number[]): number;
-    distanceSquaredTo(point: number[]): number;
-    computePlaneDistances(position: Vector3, direction: Vector3, result?: number[]): number[];
-    transform(transformation: number[]): this;
-}
-
 export declare class PanoCircleMesh extends THREE_2.Object3D implements PanoCircleMeshInterface {
     needsRender: boolean;
     private loadingMesh;
@@ -1892,8 +1745,8 @@ export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeCo
     panoCircleMeshCreator?: () => PanoCircleMeshInterface;
     /**
      * 全景瓦片登记
-     * @param fov 当前 fov
-     * @param viewSize 当前绘制区域大小
+     * @param fov - 当前 fov
+     * @param viewSize - 当前绘制区域大小
      * @returns 返回瓦片等级
      */
     tileLevelForFov?: false | ((fov: number, viewSize: THREE_2.Vector2) => number);
@@ -2026,20 +1879,6 @@ export declare interface PBMParameters {
     floorInfo?: THREE_2.Vector3 | null;
 }
 
-declare class Plane {
-    normal: Vector3;
-    distance: number;
-    constructor(normal?: number[], distance?: number);
-    fromNormalDistance(normal: number[], distance: number): this;
-    fromPointNormal(point: number[], normal: number[]): this;
-    fromCoefficients(a: number, b: number, c: number, d: number): this;
-    clone(): Plane;
-    equals(right: Plane): boolean;
-    getPointDistance(point: number[]): number;
-    transform(matrix4: Matrix4): this;
-    projectPointOntoPlane(point: number[], result?: number[]): Vector3;
-}
-
 /**
  * 相机位姿
  * [[include: coordinate.md]]
@@ -2059,56 +1898,6 @@ export declare interface Pose {
 
 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"];
 
-declare type RequestResult = null | {
-    done: () => void;
-};
-
-/**
- * Used to issue a request, without having them "deeply queued" by the browser.
- * @todo - Track requests globally, across multiple servers
- */
-declare class RequestScheduler<Identiy> {
-    private props;
-    private activeRequestCount;
-    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
-    private requestQueue;
-    private requestMap;
-    private deferred;
-    constructor(props?: RequestSchedulerOptions);
-    /**
-     * Called by an application that wants to issue a request, without having it deeply queued by the browser
-     *
-     * When the returned promise resolved, it is OK for the application to issue a request.
-     * The promise resolves to an object that contains a `done` method.
-     * When the application's request has completed (or failed), the application must call the `done` function
-     *
-     * @param identiy
-     * @param getPriority will be called when request "slots" open up,
-     *    allowing the caller to update priority or cancel the request
-     *    Highest priority executes first, priority < 0 cancels the request
-     * @returns a promise
-     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
-     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
-     *     In this case the application should not issue the request
-     */
-    scheduleRequest(identiy: Identiy, getPriority?: (identiy: Identiy) => number): Promise<RequestResult>;
-    private issueRequest;
-    /** We check requests asynchronously, to prevent multiple updates */
-    private issueNewRequests;
-    /** Refresh all requests  */
-    private issueNewRequestsAsync;
-    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
-    private updateAllRequests;
-    /** Update a single request by calling the callback */
-    private updateRequest;
-}
-
-/** RequestScheduler Options */
-declare type RequestSchedulerOptions = {
-    throttleRequests?: boolean;
-    maxRequests?: number;
-};
-
 /** Five 场景*/
 export declare class Scene extends THREE_2.Scene {
     add(...objects: AddableObject[]): this;
@@ -2256,13 +2045,13 @@ export declare interface TextureOptions {
  * the content is loaded on-demand when needed based on the view.
  * Do not construct this directly, instead access tiles through {@link Tileset3D#tileVisible}.
  */
-declare class Tile3D {
-    cacheNode?: CacheNode<Tile3D>;
+export declare class Tile3D {
+    cacheNode?: TileCacheNode<Tile3D>;
     tileset: Tileset3D;
     header: TilesetJSONNode;
     content?: TileContent;
     parent?: Tile3D;
-    boundingVolume: OrientedBoundingBox;
+    boundingVolume: TileOrientedBoundingBox;
     contentState: "UNLOADED" | "LOADING" | "PROCESSING" | "READY" | "FAILED";
     children: Tile3D[];
     depth: number;
@@ -2318,8 +2107,8 @@ declare class Tile3D {
     get contentUnloaded(): boolean;
     get contentFailed(): boolean;
     /** Get the tile's screen space error. */
-    getScreenSpaceError(frameState: FrameState, useParentLodMetric: boolean): number;
-    getPriority(): number;
+    getScreenSpaceError(frameState: TileFrameState, useParentLodMetric: boolean): number;
+    private getPriority;
     /**
      *  Requests the tile's content.
      * The request may not be made if the Request Scheduler can't prioritize it.
@@ -2329,15 +2118,15 @@ declare class Tile3D {
     /**
      * Update the tile's visibility
      */
-    updateVisibility(frameState: FrameState): void;
-    visibility(frameState: FrameState, parentVisibilityPlaneMask: number): number;
+    updateVisibility(frameState: TileFrameState): void;
+    private visibility;
     /**
      * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
-     * @param frameState The frame state.
-     * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.
+     * @param frameState - The frame state.
+     * @returns The distance, in meters, or zero if the camera is inside the bounding volume.
      */
-    distanceToTile(frameState: FrameState): number;
-    updateTransform(parentTransform?: Matrix4): void;
+    private distanceToTile;
+    private updateTransform;
 }
 
 export declare class Tile3DModel extends PBMContainer {
@@ -2357,16 +2146,78 @@ export declare class Tile3DModel extends PBMContainer {
     private lastCamera;
     private lastRenderer;
     private enabled;
-    constructor(loaderOptions?: Partial<LoaderOptions>);
+    constructor(loaderOptions?: Partial<Tile3DModelLoaderOptions>);
     get enable(): boolean;
     set enable(value: boolean);
-    load(url: WorkModelTiles_2): void;
+    load(url: WorkModelTiles): void;
     update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.PerspectiveCamera): void;
     private tilesetUpdate;
     reset(): void;
 }
 
-declare interface TileContent {
+/** Advanced loader options */
+export declare interface Tile3DModelLoaderOptions {
+    updateInterval: number;
+    maxMemoryUsage: number;
+    maxScreenSpaceError: number;
+    viewDistanceScale: number;
+    throttleRequests: boolean;
+    maxRequests: number;
+    onNodeCreated: (node: PBMGroup) => void;
+    allowHosts?: string[];
+    requestProxy?: (url: string) => string;
+    networkSubscribe?: NetworkSubscribe;
+    maxDepth?: number;
+}
+
+export declare class TileBoundingSphere {
+    center: Vector3;
+    radius: number;
+    constructor(center?: number[], radius?: number);
+    fromCenterRadius(center: number[], radius: number): this;
+    fromCornerPoints(corner: number[], oppositeCorner: number[]): this;
+    equals(right: TileBoundingSphere): boolean;
+    clone(): TileBoundingSphere;
+    union(boundingSphere: TileBoundingSphere): TileBoundingSphere;
+    expand(point: number[]): this;
+    transform(transform: Matrix4): this;
+    distanceSquaredTo(point: number[]): number;
+    distanceTo(point: number[]): number;
+    intersectPlane(plane: TilePlane): number;
+}
+
+export declare interface TileBoundingVolume {
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param sphere - The bounding sphere to apply the transformation to.
+     * @param transform - The transformation matrix to apply to the bounding sphere.
+     * @returns itself, i.e. the modified BoundingVolume.
+     */
+    transform(transform: readonly number[]): this;
+    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+    distanceSquaredTo(point: readonly number[]): number;
+    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+    distanceTo(point: readonly number[]): number;
+    /**
+     * Determines which side of a plane the oriented bounding box is located.
+     *
+     * @param plane - The plane to test against.
+     * @returns
+     *  - `INTERSECTION.INSIDE` if the entire box is on the side of the plane the normal is pointing.
+     *  - `INTERSECTION.OUTSIDE` if the entire box is on the opposite side.
+     *  - `INTERSECTION.INTERSECTING` if the box intersects the plane.
+     */
+    intersectPlane(plane: TilePlane): number;
+}
+
+export declare class TileCacheNode<T> {
+    item: T;
+    previous: TileCacheNode<T> | null;
+    next: TileCacheNode<T> | null;
+    constructor(item: T, previous: TileCacheNode<T> | null, next: TileCacheNode<T> | null);
+}
+
+export declare interface TileContent {
     version: 1;
     magic: number;
     byteLength: number;
@@ -2389,24 +2240,133 @@ declare interface TileContent {
     rtcCenter?: Float32Array;
 }
 
-declare class Tileset3D {
+export declare class TileCullingVolume {
+    static get MASK_OUTSIDE(): number;
+    static get MASK_INSIDE(): number;
+    static get MASK_INDETERMINATE(): number;
+    planes: TilePlane[];
+    constructor(planes?: TilePlane[]);
+    fromBoundingSphere(boundingSphere: {
+        center: Vector3;
+        radius: number;
+    }): this;
+    computeVisibilityWithPlaneMask(boundingVolume: TileBoundingVolume, parentPlaneMask: number): number;
+}
+
+export declare type TileFrameState = {
+    camera: {
+        position: number[];
+        direction: number[];
+        up: number[];
+    };
+    height: number;
+    cullingVolume: TileCullingVolume;
+    frameNumber: number;
+    sseDenominator: number;
+};
+
+export declare class TileOrientedBoundingBox {
+    center: Vector3;
+    halfAxes: Matrix3;
+    constructor(center?: number[], halfAxes?: number[]);
+    get halfSize(): number[];
+    get quaternion(): Quaternion;
+    fromCenterHalfSizeQuaternion(center: number[], halfSize: number[], quaternion: number[]): this;
+    clone(): TileOrientedBoundingBox;
+    equals(right: TileOrientedBoundingBox): boolean;
+    getBoundingSphere(result?: TileBoundingSphere): TileBoundingSphere;
+    intersectPlane(plane: TilePlane): number;
+    distanceTo(point: number[]): number;
+    distanceSquaredTo(point: number[]): number;
+    computePlaneDistances(position: Vector3, direction: Vector3, result?: number[]): number[];
+    transform(transformation: number[]): this;
+}
+
+export declare class TilePlane {
+    normal: Vector3;
+    distance: number;
+    constructor(normal?: number[], distance?: number);
+    fromNormalDistance(normal: number[], distance: number): this;
+    fromPointNormal(point: number[], normal: number[]): this;
+    fromCoefficients(a: number, b: number, c: number, d: number): this;
+    clone(): TilePlane;
+    equals(right: TilePlane): boolean;
+    getPointDistance(point: number[]): number;
+    transform(matrix4: Matrix4): this;
+    projectPointOntoPlane(point: number[], result?: number[]): Vector3;
+}
+
+/** Tracks one request */
+export declare type TileRequest<Identiy> = {
+    identiy: Identiy;
+    priority: number;
+    getPriority: (identiy: Identiy) => number;
+    resolve: (requestResult: TileRequestResult) => void;
+};
+
+export declare type TileRequestResult = null | {
+    done: () => void;
+};
+
+/**
+ * Used to issue a request, without having them "deeply queued" by the browser.
+ * @todo - Track requests globally, across multiple servers
+ */
+export declare class TileRequestScheduler<Identiy> {
+    private props;
+    private activeRequestCount;
+    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+    private requestQueue;
+    private requestMap;
+    private deferred;
+    constructor(props?: TileRequestSchedulerOptions);
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param identiy - Identiy
+     * @param getPriority - will be called when request "slots" open up, allowing the caller to update priority or cancel the request Highest priority executes first, priority less than 0 cancels the request
+     * @returns a promise resolves to a object (with a `done` field) when the request can be issued without queueing, resolves to `null` if the request has been cancelled (by the callback return less than 0). In this case the application should not issue the request
+     */
+    scheduleRequest(identiy: Identiy, getPriority?: (identiy: Identiy) => number): Promise<TileRequestResult>;
+    private issueRequest;
+    /** We check requests asynchronously, to prevent multiple updates */
+    private issueNewRequests;
+    /** Refresh all requests  */
+    private issueNewRequestsAsync;
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+    private updateAllRequests;
+    /** Update a single request by calling the callback */
+    private updateRequest;
+}
+
+/** RequestScheduler Options */
+export declare type TileRequestSchedulerOptions = {
+    throttleRequests?: boolean;
+    maxRequests?: number;
+};
+
+export declare class Tileset3D {
     rawJson: any;
     options: Tileset3dOptions;
     root: Tile3D;
     traverser: Tileset3DTraverser;
     cache: TilesetCache;
-    requestScheduler: RequestScheduler<string>;
+    requestScheduler: TileRequestScheduler<string>;
     selectedTiles: Tile3D[];
     requestedTiles: Tile3D[];
     memoryUsageInBytes: number;
     frameNumber: number;
     private _tiles;
     private pendingCount;
-    b3dmMapping: B3DMMapping;
+    b3dmMapping: TilesetJSON['b3dmMapping'];
     /**
      * Create a new Tileset3D
-     * @param json
-     * @param options
+     * @param json - TilesetJSON
+     * @param options - Tileset3dOptions
      */
     constructor(json: TilesetJSON, options: Tileset3dOptions);
     get maxMemoryUsage(): number;
@@ -2419,7 +2379,7 @@ declare class Tileset3D {
     get lodMetricValue(): number;
     get refine(): 'ADD' | "REPLACE";
     get tiles(): Tile3D[];
-    get floorInfo(): FloorInfo[];
+    get floorInfo(): TilesetJSON['floorInfo'];
     /** Release resources */
     reset(): void;
     /** Is the tileset loaded (update needs to have been called at least once) */
@@ -2433,7 +2393,7 @@ declare class Tileset3D {
     unloadTile(tile: Tile3D): void;
 }
 
-declare interface Tileset3dOptions {
+export declare interface Tileset3dOptions {
     throttleRequests: boolean;
     maxRequests: number;
     maxMemoryUsage: number;
@@ -2451,38 +2411,38 @@ declare interface Tileset3dOptions {
     maxDepth?: number;
 }
 
-declare class Tileset3DTraverser {
+export declare class Tileset3DTraverser {
     root: Tile3D | null;
     options: TilesetTraverserProps;
     requestedTiles: Record<string, Tile3D>;
     selectedTiles: Record<string, Tile3D>;
     emptyTiles: Record<string, Tile3D>;
-    protected _traversalStack: ManagedArray<Tile3D>;
-    protected _emptyTraversalStack: ManagedArray<Tile3D>;
-    protected _frameNumber: number | null;
+    private _traversalStack;
+    private _emptyTraversalStack;
+    private _frameNumber;
     constructor(options: TilesetTraverserProps);
-    traverse(root: Tile3D, frameState: FrameState): void;
+    traverse(root: Tile3D, frameState: TileFrameState): void;
     reset(): void;
-    executeTraversal(root: Tile3D, frameState: FrameState): void;
-    updateChildTiles(tile: Tile3D, frameState: FrameState): boolean;
-    updateAndPushChildren(tile: Tile3D, frameState: FrameState, stack: ManagedArray<Tile3D>, depth: number): boolean;
-    updateTile(tile: Tile3D, frameState: FrameState): void;
-    selectTile(tile: Tile3D, frameState: FrameState): void;
-    loadTile(tile: Tile3D, frameState: FrameState): void;
-    touchTile(tile: Tile3D, frameState: FrameState): void;
-    canTraverse(tile: Tile3D, frameState: FrameState, useParentMetric?: boolean, ignoreVisibility?: boolean): boolean;
-    shouldLoadTile(tile: Tile3D): boolean;
-    shouldSelectTile(tile: Tile3D): boolean;
-    shouldRefine(tile: Tile3D, frameState: FrameState, useParentMetric: boolean): boolean;
-    updateTileVisibility(tile: Tile3D, frameState: FrameState): void;
-    meetsScreenSpaceErrorEarly(tile: Tile3D, frameState: FrameState): boolean;
-    compareDistanceToCamera(a: Tile3D, b: Tile3D): number;
-    anyChildrenVisible(tile: Tile3D, frameState: FrameState): boolean;
-    everyChildrenVisibleIsLoaded(tile: Tile3D): boolean;
-    executeEmptyTraversal(root: Tile3D, frameState: FrameState): boolean;
-}
-
-declare class TilesetCache {
+    private executeTraversal;
+    private updateChildTiles;
+    private updateAndPushChildren;
+    updateTile(tile: Tile3D, frameState: TileFrameState): void;
+    selectTile(tile: Tile3D, frameState: TileFrameState): void;
+    loadTile(tile: Tile3D, frameState: TileFrameState): void;
+    touchTile(tile: Tile3D, frameState: TileFrameState): void;
+    private canTraverse;
+    private shouldLoadTile;
+    private shouldSelectTile;
+    private shouldRefine;
+    private updateTileVisibility;
+    private meetsScreenSpaceErrorEarly;
+    private compareDistanceToCamera;
+    private anyChildrenVisible;
+    private everyChildrenVisibleIsLoaded;
+    private executeEmptyTraversal;
+}
+
+export declare class TilesetCache {
     private list;
     private sentinel;
     constructor();
@@ -2493,7 +2453,7 @@ declare class TilesetCache {
     unloadTiles(isOverMemory: () => boolean, unloadCallback?: (tile: Tile3D) => void): void;
 }
 
-declare interface TilesetJSON {
+export declare interface TilesetJSON {
     asset: {
         gltfUpAxis: "X" | "Y" | "Z";
         version: "1.0";
@@ -2504,11 +2464,17 @@ declare interface TilesetJSON {
     lodMetricValue: number;
     root: TilesetJSONNode;
     type: "TILES3D";
-    floorInfo: FloorInfo[] | [];
-    b3dmMapping: B3DMMapping;
+    floorInfo: {
+        ground: number;
+        height: number;
+    }[];
+    b3dmMapping: {
+        b3dm_base_url: string;
+        b3dm_url: Record<string, string>;
+    };
 }
 
-declare interface TilesetJSONNode {
+export declare interface TilesetJSONNode {
     boundingVolume: {
         box: number[];
     };
@@ -2526,12 +2492,12 @@ declare interface TilesetJSONNode {
     type: "EMPTY" | "SCENEGRAPH" | "MESH";
 }
 
-declare type TilesetTraverserProps = {
+export declare type TilesetTraverserProps = {
     loadSiblings: boolean;
     skipLevelOfDetail: boolean;
     maxScreenSpaceError: number;
     maxDepth?: number;
-    onTraversalEnd: (frameState: FrameState) => any;
+    onTraversalEnd: (frameState: TileFrameState) => any;
 };
 
 export declare interface TopviewControllerCustomInitArgs extends Omit<FloorplanControllerCustomInitArgs, "defaultLongitude" | "defaultLatitude" | "maxLatitude" | "minLatitude"> {
@@ -2624,13 +2590,6 @@ export declare interface WorkModelTiles {
     b3md_mappings_url_md5: string;
 }
 
-declare interface WorkModelTiles_2 {
-    tileset_url: string;
-    tileset_url_md5: string;
-    b3md_mappings_url: string;
-    b3md_mappings_url_md5: string;
-}
-
 /** 每个点位的数据 */
 export declare interface WorkObserver {
     /** 点位序号 */