vis-core 0.31.33 → 0.32.0

package/dist/index.d.ts

@@ -17,10 +17,10 @@ import { MeshObject } from 'gl-draw';
 import { MultiPolygon } from 'geojson';
 import { NodeObject } from 'gl-draw';
 import { Pencil } from 'gl-draw';
-import { PickFunctionsItem } from 'gl-draw';
 import { PointLightObject } from 'gl-draw';
 import { Polygon } from 'geojson';
 import { Position } from 'geojson';
+import { ProjectionOptions } from 'gl-draw';
 import { RectAreaLightObject } from 'gl-draw';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
 import { SpotLightObject } from 'gl-draw';
@@ -32,7 +32,6 @@ import { Water } from './Water2';
 
 declare class AmbientLight extends AmbientLightObject {
     constructor(...options: ConstructorParameters<typeof AmbientLightObject>);
-    render(): void;
 }
 
 export declare namespace animationUtils {
@@ -48,21 +47,16 @@ export declare namespace animationUtils {
 
 declare class Arc extends LineObject {
     objectType: string;
-    options: Options_2;
-    helperMeshPosition?: THREE.Vector3[];
-    constructor(options: Options_2);
-    static getInitOptions(pencil: default_2, options: Options_2): {
-        from: THREE.Vector3Tuple;
-        to: THREE.Vector3Tuple;
-    };
+    options: Options;
+    constructor(options: Options);
     create(): Promise<void>;
-    instantiate(ops: Parameters<BaseObject['instantiate']>[0]): Promise<this>;
     line: {
         options: {
             nodes: THREE.Vector3[];
         };
     };
-    private _tempCurve;
+    getCurve(): THREE.CubicBezierCurve3;
+    setControlPoints(points: [THREE.Vector3, THREE.Vector3, THREE.Vector3, THREE.Vector3]): void;
     setPath(from: THREE.Vector3 | number[], to: THREE.Vector3 | number[], radius: number, setPointWidth?: (p: number) => number): void;
     pickTube: Tube | null;
     addPickTarget(radius?: number, show?: boolean): Promise<Tube>;
@@ -75,7 +69,6 @@ declare class Arc extends LineObject {
         onComplete?: (...args: any[]) => void;
         onRepeat?: (count: number) => void;
     }): void;
-    update(): void;
     render(): void;
 }
 
@@ -88,15 +81,22 @@ declare class Area extends GroupObject {
     rebuildFromScene(): void;
 }
 
+/** vis-core 的运行时入口只接受编辑平台导出的完整场景文档。 */
+export declare function assertRuntimeSceneDocument(value: unknown): asserts value is VisSceneDocument & Record<string, any>;
+
+export declare function assertSupportedSceneDocument(value: unknown): void;
+
 export declare class Base extends Camera {
     static VisName: string;
-    private static _loadingCount;
-    playing: boolean;
+    runtimePolicy: {
+        observeParentScale: boolean;
+        applyDisabledMouseButtons: boolean;
+        cacheCityGeometry: boolean;
+    };
     leftTruck: boolean;
     options: BaseOptions;
     showState: boolean;
     settings: Record<string, any>;
-    extendsOptions: Record<string, any>;
     lead: Lead;
     mList: default_2['mList'];
     tier0: boolean;
@@ -105,6 +105,7 @@ export declare class Base extends Camera {
     roomEnvMap?: THREE.Texture;
     visName: string;
     private detectRes?;
+    private ownsPencil;
     publicDir: Record<string, string>;
     constructor(options: BaseOptions);
     private getDetectRes;
@@ -115,125 +116,70 @@ export declare class Base extends Camera {
     private resolveRendererDepthBufferOptions;
     private showDetectRes;
     setOptions(options: Record<string, any>): void;
-    syncExtendsOptionToScene(name: string, value: any): void;
     fromJSON(jsonOrUrl: Record<string, any> | string, hooksE?: Record<string, any>): Promise<void>;
-    private parseHooks;
-    loaderAdd(...args: any): void;
-    initGroup(): Promise<void>;
-    initMaterial(...args: any): Promise<void>;
-    initVis(...args: any): Promise<void>;
-    initFromScene(scene?: any, set?: Record<string, any>): Promise<void>;
-    init(...args: any[]): Promise<void>;
-    beforeInit(): Promise<void>;
-    afterInit(): Promise<void>;
+    private runtimeInitialization?;
+    private disposed;
+    /* Excluded from this release type: initializeRuntime */
+    /** 子类扩展点：运行环境只初始化一次，适合建立投影和绑定控制器事件。 */
+    protected onRuntimeReady(): Promise<void>;
+    /** 子类扩展点：恢复场景引用和运行时派生状态，不生成地图几何或移动相机。 */
+    protected onSceneRestored(): Promise<void>;
+    /** 子类扩展点：释放额外引用和监听；页面资源由 Base 统一释放。 */
+    protected onDispose(): void;
+    protected get objectTypes(): Record<string, any>;
+    protected get defaultCameraUp(): THREE.Vector3;
     private observeScale;
-    initPencil(): Promise<void>;
+    private createRuntime;
     private sceneActive;
     setSceneActive(): void;
-    initCameraUserData(): void;
-    initSceneUserData(): void;
-    initBaseObjectUserData(baseObject: BaseObject): void;
-    private applyMapLabelStyle;
+    /** 把 Pencil 生命周期交给外部场景管理器，当前实例仅拥有自己的 page。 */
+    releasePencilOwnership(): void;
+    private initSceneUserData;
+    /** Save a partial object state and apply its effects without replaying other state. */
+    setObjectState(object: BaseObject, patch: Record<string, any>): BaseObject<THREE.Object3D<THREE.Object3DEventMap>>;
+    applyObjectState(object: BaseObject, state?: Record<string, any>): void;
+    /** 场景页提交后的默认入场动画；地图可覆盖为更有空间感的过渡。 */
+    playEnterTransition({ duration, onPrepared, }: SceneEnterTransitionOptions): Promise<void>;
     addCSS3DRenderer(container?: HTMLElement): void;
     initSettingsObj?: Record<string, any>;
     mouseButtonsActiveStore: Record<string, any> | null;
-    initSettings(): void;
+    private initSettings;
     handleSetting(key: string, value: any): void;
-    show(): void;
-    showAction(): void;
+    protected prepareInitialCamera(): Promise<void>;
+    private showing?;
+    show(): Promise<void>;
     hide(): void;
     exportScene(): THREE.Object3DJSON;
     exportBaseObject(baseObject: BaseObject): THREE.Object3DJSON;
-    restoreBaseObject(data: string | THREE.Object3DJSON, target?: BaseObject, objectsMap?: {
-        Point: Point;
-        Arc: typeof Arc;
-        Model: Model;
-        Plane: Plane;
-        PlaneShadow: PlaneShadow;
-        Sphere: Sphere;
-        Sprite: typeof Sprite;
-        Box: Box;
-        Circle: Circle;
-        Tube: Tube;
-        Ring: Ring;
-        AmbientLight: AmbientLight;
-        DirectionalLight: DirectionalLight;
-        PointLight: PointLight;
-        SpotLight: SpotLight;
-        HemisphereLight: HemisphereLight;
-        RectAreaLight: RectAreaLight;
-        Node: typeof NodeObject;
-        ExtrudePolygon: ExtrudePolygonObject;
-        Line: typeof LineObject;
-        Group: GroupObject;
-    }): Promise<BaseObject<THREE.Object3D<THREE.Object3DEventMap>>>;
-    restoreScene(str: string | THREE.Object3DJSON, objectsMap?: {
-        Point: Point;
-        Arc: typeof Arc;
-        Model: Model;
-        Plane: Plane;
-        PlaneShadow: PlaneShadow;
-        Sphere: Sphere;
-        Sprite: typeof Sprite;
-        Box: Box;
-        Circle: Circle;
-        Tube: Tube;
-        Ring: Ring;
-        AmbientLight: AmbientLight;
-        DirectionalLight: DirectionalLight;
-        PointLight: PointLight;
-        SpotLight: SpotLight;
-        HemisphereLight: HemisphereLight;
-        RectAreaLight: RectAreaLight;
-        Node: typeof NodeObject;
-        ExtrudePolygon: ExtrudePolygonObject;
-        Line: typeof LineObject;
-        Group: GroupObject;
-    }): Promise<void>;
-    rebuildFromScene(): Promise<void>;
+    restoreBaseObject(data: string | THREE.Object3DJSON, target?: BaseObject, objectsMap?: Record<string, any>): Promise<BaseObject<THREE.Object3D<THREE.Object3DEventMap>>>;
+    restoreScene(str: string | THREE.Object3DJSON, objectsMap?: Record<string, any>): Promise<void>;
     getClassRefByType(type: string): typeof BaseObject;
-    addGroup(): Promise<GroupObject>;
+    addGroup(): Promise< GroupObject>;
     addCSS2D(dom: HTMLElement, options?: {
         display?: string;
         onTop?: number;
         target?: BaseObject;
-    }): Promise<NodeObject>;
+    }): Promise< NodeObject>;
     addCSS3D(dom: HTMLElement, options?: {
         display?: string;
         onTop?: number;
         type?: '3d' | '3dSprite';
         target?: BaseObject;
-    }): Promise<NodeObject>;
+    }): Promise< NodeObject>;
     private addNode;
     getRoomEnvMap(): THREE.Texture<unknown, THREE.TextureEventMap>;
-    handlePick(objArr: PickFunctionsItem['objArr'], type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): void;
     getScreenPosition(x: number, y: number, z: number): {
         x: number;
         y: number;
     };
     uuidByObject(object: THREE.Object3D): string | undefined;
-    objectByUuid(key: string): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap> | THREE.Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap> | undefined;
-    uuidByBaseObject(object: BaseObject): string | undefined;
+    objectByUuid(key: string): THREE.Object3D<THREE.Object3DEventMap>;
+    uuidByBaseObject(object: BaseObject): string;
     baseObjectByUuid(key: `arc${string}`): Arc;
     baseObjectByUuid(key: `sprite${string}`): Sprite;
     baseObjectByUuid(key: string): BaseObject;
+    private normalizeBaseObjectKey;
     baseObjectByName(name: string): BaseObject<THREE.Object3D<THREE.Object3DEventMap>> | undefined;
-    private _selectOptionMaps;
-    findSelectItem(key: any, val: any): SelectedMeta | undefined;
-    selectOption: SelectedMeta[];
-    changeSelectOption(): void;
-    private _mListOptionsMaps;
-    findMListSelectItem(key: any, val: any): any;
-    mListOptions: {
-        key: string;
-        name: string;
-        type: string;
-        use: number;
-        object: THREE.Mesh;
-        material: THREE.Material;
-        baseObject: BaseObject;
-    }[];
-    changeMListOptions(): never[] | undefined;
     dispose(): void;
 }
 
@@ -289,6 +235,8 @@ declare interface BaseOptions {
     tier?: number;
     observeParentScale?: boolean;
     createIfNeeded?: boolean;
+    /** 相机输入与场景运行控制，由平台随场景参数导出。 */
+    controls?: SceneControlsOptions;
     [key: string]: any;
 }
 
@@ -316,7 +264,7 @@ declare class Camera extends Event_2 {
     cameraState: Record<string, number[]>;
     cameraStateActive: string;
     setSaveCamera(type: string): void;
-    useSaveCamera(type: string, enableTransition?: boolean): Promise<boolean>;
+    useSaveCamera(type: string, enableTransition?: boolean, smoothTime?: number): Promise<boolean>;
     lookAt(positionX: number, positionY: number, positionZ: number, targetX: number, targetY: number, targetZ: number, enableTransition?: boolean, smoothTime?: number): Promise<void>;
     truck(x: number, y: number, enableTransition?: boolean, smoothTime?: number): Promise<void>;
     moveTo(x: number, y: number, z: number, enableTransition?: boolean, smoothTime?: number): Promise<void>;
@@ -343,7 +291,7 @@ declare class City {
     adcode: number;
     pcenter: [number, number];
     pscale: number;
-    projection: ReturnType<typeof getProjection_2>;
+    projection: GeoProjection;
     options: CityOptions;
     group: GroupObject;
     building: Building;
@@ -354,8 +302,9 @@ declare class City {
     constructor(pencil: Pencil);
     setOptions(options: CityOptions): void;
     multiplyScalar: number;
+    private getProjectionOptions;
     fixNearFar(n?: number, f?: number): void;
-    init(): Promise<void>;
+    init(existingGroup?: GroupObject): Promise<void>;
     drawCityPlane(adcode: number, target?: BaseObject): Promise<void>;
     drawBuilding(options?: {
         jsonUrl?: string;
@@ -369,7 +318,7 @@ declare class City {
         type?: 'river' | 'grassland';
         oArr?: number[];
         grey?: boolean;
-    }): Promise<Area | undefined>;
+    }): Promise< Area | undefined>;
     drawRoad(options?: {
         jsonUrl?: string;
         meters?: number;
@@ -383,6 +332,7 @@ declare interface CityOptions {
     jsonName: string;
     cacheKey?: string;
     center?: [number, number];
+    projectionType?: ProjectionOptions['projectionType'];
     plane?: boolean;
     grey?: boolean;
     showBuilding?: boolean;
@@ -392,6 +342,12 @@ declare interface CityOptions {
     showGrassland?: boolean;
     showRiver?: boolean;
     setWaterMaterial?: boolean;
+    dataSources?: {
+        building?: string;
+        road?: string;
+        river?: string;
+        grassland?: string;
+    };
 }
 
 declare class CityPlane extends MeshObject {
@@ -402,7 +358,7 @@ declare class CityPlane extends MeshObject {
     water?: Water;
     create(): Promise<void>;
     rebuildFromScene(): void;
-    addWater(): void;
+    addWater(normalMaps: [THREE.Texture, THREE.Texture]): void;
 }
 
 declare class ContinentsBg extends GroupObject {
@@ -428,26 +384,13 @@ export declare class Earth extends Base {
     static VisName: string;
     leftTruck: boolean;
     options: Required<EarthOptions>;
-    extendsOptions: Record<string, any>;
     map: PlaneMap;
+    sphere?: BaseObject;
+    secondaryMap?: PlaneMap;
     get mapArea(): ExtrudePolygonObject[];
     setOptions(options: EarthOptions): void;
     handleSetting(key: string, value: any): void;
-    show(): void;
-    animationIn(): void;
-    initLight(): Promise<void>;
-    getLocationPosition(location: [number, number], dr?: number): [number, number, number];
-    getRadius(): number;
-    checkBehindEarth(objArr: () => BaseObject[], cb: (obj: BaseObject[], res: boolean[]) => any): void;
-    /**
-     * 设置物体在球面上的位置和旋转，使其垂直于球面
-     * @param object - 要设置的物体
-     * @param location - 经纬度 [经度, 纬度]
-     * @param height - 距离球面的高度，默认为0
-     * @param upAxis - 物体的up轴方向，默认为Y轴 [0, 1, 0]
-     */
-    setObjectOnSphere(baseObject: BaseObject, location: [number, number], height?: number, upAxis?: [number, number, number]): void;
-    restoreScene(str: string, objectsMap?: {
+    protected get objectTypes(): {
         Earth: Earth_2;
         SphereShadow: SphereShadow;
         Countries: typeof PlaneMap;
@@ -473,29 +416,48 @@ export declare class Earth extends Base {
         ExtrudePolygon: ExtrudePolygonObject;
         Line: LineObject;
         Group: GroupObject;
-    }): Promise<void>;
-    private _getChinaPlaneCopy;
-    ensureChinaPlaneCopyInScene(): Promise<void>;
-    clearChinaPlaneCopyInScene(): void;
-    private _syncChinaPlaneCopy;
-    rebuildFromScene(): Promise<void>;
+    };
+    private rotationControls?;
+    private readonly stopAutoRotate;
+    private readonly resumeAutoRotate;
+    protected onRuntimeReady(): Promise<void>;
+    protected onDispose(): void;
+    getLocationPosition(location: [number, number], dr?: number): [number, number, number];
+    getRadius(): number;
+    checkBehindEarth(objArr: () => BaseObject[], cb: (obj: BaseObject[], res: boolean[]) => any): void;
+    /**
+     * 设置物体在球面上的位置和旋转，使其垂直于球面
+     * @param object - 要设置的物体
+     * @param location - 经纬度 [经度, 纬度]
+     * @param height - 距离球面的高度，默认为0
+     * @param upAxis - 物体的up轴方向，默认为Y轴 [0, 1, 0]
+     */
+    setObjectOnSphere(baseObject: BaseObject, location: [number, number], height?: number, upAxis?: [number, number, number]): void;
+    getSceneBindings(): EarthSceneBindings;
+    protected onSceneRestored(): Promise<void>;
 }
 
 declare class Earth_2 extends Sphere {
     objectType: string;
-    options: Required<Options_6>;
-    constructor(options: Options_6);
+    options: Required<Options_4>;
+    constructor(options: Options_4);
     create(): void;
     rebuildFromScene(): void;
 }
 
 declare interface EarthOptions extends BaseOptions {
+    sceneBindings?: EarthSceneBindings;
     mapDepth?: number;
     otherMapDepth?: number;
     radius?: number;
     copyChinaPlane?: boolean;
     mergeSide?: boolean;
-    style?: 'chinaPlate' | 'countryPlate' | 'base';
+}
+
+declare interface EarthSceneBindings {
+    sphere?: string;
+    map?: string;
+    secondaryMap?: string;
 }
 
 declare class Event_2 {
@@ -520,85 +482,36 @@ declare const findAdcodeInfo: (adcode: number) => {
     b: number[];
 } | undefined;
 
-export declare interface FixConfig {
-    [key: `${string}`]: {
-        s?: string[];
-        z?: string[];
-        t?: string[];
-        b?: string[];
-        l?: string[];
-        r?: string[];
-    };
-}
-
 declare type GeoJSON_2 = FeatureCollection<Polygon | MultiPolygon>;
 
 declare type GeoJSON_3 = FeatureCollection<Polygon | MultiPolygon>;
 
 declare type GeoJSON_4 = FeatureCollection<Polygon | MultiPolygon>;
 
-declare const getProjection: (options: {
-    center: [number, number];
-    scale: number;
-    projectionType?: "mercator" | "equirectangular" | "winkel3";
-    translate?: [number, number];
-    precision?: number;
-    rotate?: [number, number];
-}) => GeoProjection;
-
-declare const getProjection_2: (options: {
-    center: [number, number];
-    scale: number;
-    projectionType?: "mercator" | "equirectangular" | "winkel3";
-    translate?: [number, number];
-    precision?: number;
-    rotate?: [number, number];
-}) => GeoProjection;
+export declare function getSceneDocument(document: VisSceneDocument, sceneId?: string): SceneViewportDocument;
 
 declare class HemisphereLight extends HemisphereLightObject {
-    render(): void;
 }
 
+/**
+ * 新场景文档以完整场景快照作为恢复基线。
+ * 未带标记的 JSON 属于旧格式，仍由编辑器的兼容流程处理。
+ */
+export declare function isSceneDocument(value: unknown): value is SceneDocumentMarker & Record<string, any>;
+
 declare class Map_2 extends Base {
     static VisName: string;
     options: Required<MapCityOptions>;
-    mapHistory: {
+    /** 当前唯一主地图的运行时状态。 */
+    mapObj: {
         map: PlaneMap;
         mapInfo: NonNullable<ReturnType<typeof findAdcodeInfo>>;
         z: number;
         cX: number;
         cY: number;
         depth: number;
-        controls?: {
-            lookAt: [number, number, number, number, number, number];
-            polarAngle: number;
-            azimuthAngle: number;
-        };
-        userControls?: {
-            lookAt: [number, number, number, number, number, number];
-            polarAngle: number;
-            azimuthAngle: number;
-        };
-    }[];
-    get mapObj(): {
-        map: PlaneMap;
-        mapInfo: NonNullable<ReturnType<typeof findAdcodeInfo>>;
-        z: number;
-        cX: number;
-        cY: number;
-        depth: number;
-        controls?: {
-            lookAt: [number, number, number, number, number, number];
-            polarAngle: number;
-            azimuthAngle: number;
-        };
-        userControls?: {
-            lookAt: [number, number, number, number, number, number];
-            polarAngle: number;
-            azimuthAngle: number;
-        };
-    };
-    get map(): PlaneMap;
+    } | undefined;
+    get map(): PlaneMap | undefined;
     get mapInfo(): {
         adcode: number;
         lng: number;
@@ -608,59 +521,80 @@ declare class Map_2 extends Base {
         parent: number;
         c: number[];
         b: number[];
-    };
-    get mapArea(): ExtrudePolygonObject[];
-    get mapLine(): LineObject[];
-    get adcodes(): number[];
+    } | undefined;
+    get mapArea(): ExtrudePolygonObject[] | undefined;
+    get mapLine(): LineObject[] | undefined;
+    /** 当前已恢复或生成的主地图区域；空场景为 undefined。 */
+    get adcode(): number | undefined;
     activePlaneMap: PlaneMap | null;
-    isAnimating: boolean;
     parentBg: PlaneMap[];
     continentsBg?: ContinentsBg;
     group: GroupObject;
-    projection: ReturnType<typeof getProjection>;
+    projection: GeoProjection;
     pcenter: [number, number];
     pscale: number;
     meters: number;
     cityVis: City[];
     cityGroup: GroupObject[];
-    extendsOptions: Record<string, any>;
+    /**
+     * 目标模板默认保存视角对应的地图基准。地区替换会修改 adcode、center
+     * 和 sceneBindings，因此在场景刚恢复时记录，供后续 fitTo 复用设计师视角。
+     */
+    private regionCameraFitReference?;
     setOptions(options: MapOptions): void;
-    initGroup(): Promise<void>;
     private _getProjectionCenter;
     private _getProjectionRotate;
     private _getSplitPolygons;
-    beforeInit(): Promise<void>;
-    private clickHandleDrillDownMark;
-    private clickOusideBackMark;
-    afterInit(): Promise<void>;
+    protected get objectTypes(): {
+        PlaneMap: typeof PlaneMap;
+        ContinentsBg: typeof ContinentsBg;
+        Mountain: Mountain;
+        CityPlane: CityPlane;
+        Area: Area;
+        Building: Building;
+        Road: Road;
+        Point: Point;
+        Arc: Arc;
+        Model: Model;
+        Plane: Plane;
+        PlaneShadow: PlaneShadow;
+        Sphere: Sphere;
+        Sprite: Sprite;
+        Box: Box;
+        Circle: Circle;
+        Tube: Tube;
+        Ring: Ring;
+        AmbientLight: AmbientLight;
+        DirectionalLight: DirectionalLight;
+        PointLight: PointLight;
+        SpotLight: SpotLight;
+        HemisphereLight: HemisphereLight;
+        RectAreaLight: RectAreaLight;
+        Node: NodeObject;
+        ExtrudePolygon: ExtrudePolygonObject;
+        Line: LineObject;
+        Group: typeof GroupObject;
+    };
+    protected get defaultCameraUp(): THREE.Vector3;
+    protected onRuntimeReady(): Promise<void>;
+    protected prepareInitialCamera(): Promise<void>;
+    private updateMapBoundary;
+    /* Excluded from this release type: finalizeRegionGeometry */
     initCityVis(adcode: number, grey?: boolean): Promise<City>;
     initCityOnMap(adcode: number): Promise<void>;
-    initVisBg(): Promise<void>;
-    initVis(): Promise<void>;
-    loaderAddBg(): void;
-    initMaterialBg(): Promise<void>;
     private _getParentBgMetrics;
-    private _clearParentBgInScene;
-    private _ensureParentBgInScene;
-    private _clearContinentsBgInScene;
-    private _ensureContinentsBgInScene;
+    clearParentBackground(): void;
+    ensureParentBackground(): Promise<{
+        planeWidth: number;
+        planeHeight: number;
+        center: THREE.Vector3;
+    } | undefined>;
+    clearContinentsBackground(): void;
+    ensureContinentsBackground(): Promise<void>;
     consoleMousePostion(): void;
-    caId: string | number | undefined;
-    showAction(): Promise<void>;
-    hide(): Promise<void>;
     shadowMapEnabled(): Promise<void>;
-    getOptionsDepth(adcode: number): number;
-    getDepth(adcode: number): number;
     getReferenceScale(bboxa: number[], bboxb: number[]): number;
     getAdcodeShowLevel(adcode: number, fix?: boolean): string | undefined;
-    private handleClick;
-    beforeShowMap(_adcodes: number[]): boolean;
-    getAdcodes(adcode: number): number[];
-    showMap({ adcode, adcodes: prevAdcodes, duration, }: {
-        adcode?: number;
-        adcodes?: number[];
-        duration?: number;
-    }): Promise<void>;
     drawLabels(): Promise<void>;
     private labelGroupObject3dUserData;
     eraseLabels(): void;
@@ -687,11 +621,9 @@ declare class Map_2 extends Base {
     private _loadGeojsonFromConfig;
     private _loadBaseGeojson;
     private getGeojson;
-    private handleDrillDown;
-    saveCamvasState(type: 'userControls' | 'controls', index: number): void;
-    fixNear(adcode: number): void;
+    /* Excluded from this release type: buildRegion */
     private calcPaddingFromReference;
-    fitTo(obj: BaseObject, { polarAngle, azimuthAngle, reference, z, handleStart, adcode, enableTransition, }?: {
+    fitTo(obj: BaseObject, { polarAngle, azimuthAngle, reference, z, handleStart, adcode, enableTransition, smoothTime, }?: {
         adcode?: number;
         polarAngle?: number;
         azimuthAngle?: number;
@@ -701,9 +633,11 @@ declare class Map_2 extends Base {
             center?: [number, number];
         };
         enableTransition?: boolean;
+        smoothTime?: number;
         z?: number;
         handleStart?: () => void;
     }): Promise<void>;
+    private regionAppearance?;
     drawPlaneMap({ geojson, extrudeLineGeojson, bbox, depth, extrudelineBloom, adcode, }: {
         geojson: GeoJSON_3;
         extrudeLineGeojson?: GeoJSON_3;
@@ -712,10 +646,6 @@ declare class Map_2 extends Base {
         adcode: number;
         extrudelineBloom?: boolean;
     }): Promise<PlaneMap>;
-    private handleBack;
-    handleLookBack(duration?: number): Promise<void>;
-    compareLocations(currentO: any[], destinationO: any[]): number[];
-    private setAdcode;
     setPadding(padding: [number, number, number, number], fitTo?: boolean, enableTransition?: boolean): void;
     findAdcodeInfo(adcode: number): {
         adcode: number;
@@ -735,7 +665,8 @@ declare class Map_2 extends Base {
      * 根据当前 options.center 重新计算投影
      */
     private updateProjection;
-    rebuildFromScene(): Promise<void>;
+    protected onSceneRestored(): Promise<void>;
+    getSceneBindings(): MapSceneBindings;
     /**
      * 快照：捕获 PlaneMap 上用户添加的叠加对象
      */
@@ -749,41 +680,30 @@ declare class Map_2 extends Base {
      * 根据 switchFixConfig 对场景中的对象做位置/缩放修复
      */
     private applySwitchFixConfig;
-    switchAdcode(targetAdcode: number, key: string): Promise<false | undefined>;
-    restoreScene(str: string, objectsMap?: {
-        PlaneMap: typeof PlaneMap;
-        ContinentsBg: typeof ContinentsBg;
-        Mountain: Mountain;
-        CityPlane: CityPlane;
-        Area: Area;
-        Building: Building;
-        Road: Road;
-        Point: Point;
-        Arc: Arc;
-        Model: Model;
-        Plane: Plane;
-        PlaneShadow: PlaneShadow;
-        Sphere: Sphere;
-        Sprite: Sprite;
-        Box: Box;
-        Circle: Circle;
-        Tube: Tube;
-        Ring: Ring;
-        AmbientLight: AmbientLight;
-        DirectionalLight: DirectionalLight;
-        PointLight: PointLight;
-        SpotLight: SpotLight;
-        HemisphereLight: HemisphereLight;
-        RectAreaLight: RectAreaLight;
-        Node: NodeObject;
-        ExtrudePolygon: typeof ExtrudePolygonObject;
-        Line: LineObject;
-        Group: typeof GroupObject;
-    }): Promise<void>;
-    dispose(): void;
+    /* Excluded from this release type: rebuildRegion */
+    /** 候选区域提交后的相机过渡，不参与场景序列化。 */
+    playRegionEnterTransition({ duration, sourceCamera, onPrepared, }: MapRegionEnterTransitionOptions): Promise<void>;
+    private setRegionTexture;
+    applyRegionTextureRules(adcode: number): Promise<void>;
+    protected onDispose(): void;
 }
 export { Map_2 as Map }
 
+declare interface MapAssetSources {
+    worldGeojson: string;
+    worldLiteGeojson: string;
+    regionGeojson: string;
+    regionLiteGeojson: string;
+    continentsLiteGeojson: string;
+    waterNormalMaps?: [string, string];
+    city?: {
+        building?: string;
+        road?: string;
+        river?: string;
+        grassland?: string;
+    };
+}
+
 declare interface MapCityOptions extends MapOptions {
     cacheCity?: boolean;
     nearbyCities?: boolean | 'full';
@@ -798,139 +718,16 @@ declare interface MapCityOptions extends MapOptions {
     citySSAO?: boolean;
 }
 
-export declare interface MapEventHandlers {
-    [key: string]: (...args: any[]) => void;
-}
-
-export declare class MapManager extends Event_2 {
-    private container;
-    private controlsContainer?;
-    private assetsPrefix?;
-    private fixConfig?;
-    private raycasterPointsThreshold;
-    private readonly MAX_ZOOM_FACTOR;
-    private readonly MIN_ZOOM_FACTOR;
-    private mapInstances;
-    private mapDistances;
-    private mapConfigs;
-    private mapReference;
-    private mapBloomConfig;
-    private currentMap;
-    private currentZoom;
-    private mapMultiplyScalar;
-    private mapPadding?;
-    private isInitializing;
-    private rmTemplateIdentifier;
-    private geojsonExtensions;
-    private areaHoverMlistName;
-    private distanceChangeMlistName;
-    private showBuildingOnlyWithoutChildren;
-    private groups;
-    private areaCloseTimer;
-    private key;
-    private topAdcode;
-    private clickHandleDrillDown;
-    private clickOusideBack;
-    static findAdcodeInfoByName: (name: string) => {
-        adcode: number;
-        lng: number;
-        lat: number;
-        name: string;
-        level: string;
-        parent: number;
-        c: number[];
-        b: number[];
-    } | undefined;
-    static getAdcodeShowLevel: (adcode: number, fix?: boolean) => string | undefined;
-    static findAdcodeInfo: (adcode: number) => {
-        adcode: number;
-        lng: number;
-        lat: number;
-        name: string;
-        level: string;
-        parent: number;
-        c: number[];
-        b: number[];
-    } | undefined;
-    static extendsAdcodeAll: (cb: any) => void;
-    constructor(config: MapManagerConfig);
-    /**
-     * 获取当前地图实例
-     */
-    getCurrentMap(): Map_2 | null;
-    /**
-     * 获取当前缩放级别
-     */
-    getCurrentZoom(): number;
-    /**
-     * 初始化地图
-     */
-    showMap(adcodeArr: number[], fixedAdcode?: boolean): Promise<Map_2 | null>;
-    /**
-     * 创建地图实例
-     */
-    private createMapInstance;
-    /**
-     * 绑定区域交互事件
-     */
-    private bindAreaEvents;
-    /**
-     * 设置缩放级别
-     */
-    setZoom(zoom: number): void;
-    /**
-     * 创建分组
-     * @param groupId 分组ID，用于后续管理
-     * @returns 分组实例
-     */
-    createGroup(groupId: string): Promise<Awaited<ReturnType<Map_2['addGroup']>> | null>;
-    /**
-     * 获取分组
-     */
-    getGroup(groupId: string): Awaited<ReturnType<Map_2['addGroup']>> | undefined;
-    /**
-     * 清除指定分组
-     */
-    clearGroup(groupId: string): void;
-    /**
-     * 清除所有分组
-     */
-    clearAllGroups(): void;
-    /**
-     * 清除区域关闭定时器（供 PortalModal 调用）
-     */
-    clearAreaCloseTimer(): void;
-    triggerAreaLeave({ areaName }?: {
-        areaName: string;
-    }): void;
-    /**
-     * 销毁所有地图实例
-     */
-    dispose(): void;
-}
-
-export declare interface MapManagerConfig {
-    key?: string;
-    container: HTMLElement;
-    controlsContainer?: HTMLElement;
-    assetsPrefix?: string;
-    fixConfig?: FixConfig;
-    raycasterPointsThreshold?: number;
-    mapPadding?: [number, number, number, number];
-    rmTemplateIdentifier?: boolean;
-    geojsonExtensions?: Record<string, any[]>;
-    mapConfigs?: Record<string, any>;
-    areaHoverMlistName?: Record<string, [string, string, number?]>;
-    distanceChangeMlistName?: Record<string, [string, string, number?][]>;
-    topAdcode?: number;
-    showBuildingOnlyWithoutChildren?: boolean;
-    clickHandleDrillDown?: boolean;
-    clickOusideBack?: boolean;
-    mapMultiplyScalar?: number;
+declare interface MapLabelStyle {
+    color?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: string;
 }
 
 declare interface MapOptions extends BaseOptions {
     adcode: number;
+    sceneBindings?: MapSceneBindings;
     center?: [number, number];
     parentBg?: boolean | number;
     parentBgDepth?: number;
@@ -938,20 +735,13 @@ declare interface MapOptions extends BaseOptions {
     topSegments?: number;
     continentsBg?: boolean;
     continentsBgDepth?: number;
-    clickOusideBack?: boolean;
-    mapDepth?: number[];
-    depthReference?: number[];
+    mapDepth?: number;
     mapPadding?: [number, number, number, number];
     fixGeojson?: Record<string, string>;
-    plateInCenter?: boolean;
-    clickHandleDrillDown?: boolean;
-    drillDownPlateInCenter?: boolean;
-    drillDownHideParent?: boolean;
-    drillDownRestrictions?: 'city' | 'district';
-    drillDownSecondLevelMats?: boolean;
-    drillDownThirdLevelMats?: boolean;
     showDistrict?: boolean;
     showLabel?: boolean | 'lite';
+    labelStyle?: MapLabelStyle;
+    labelOffsets?: Record<string, [number, number, number]>;
     lineWidth?: number;
     lineOffset?: number;
     extrudeLineWidth?: number;
@@ -961,30 +751,72 @@ declare interface MapOptions extends BaseOptions {
     projectionType?: 'mercator' | 'equirectangular' | 'winkel3';
     polarAngle?: number;
     azimuthAngle?: number;
-    showOneLevel?: boolean;
-    handleBackKeepCamvasState?: boolean;
     worldPacificCentre?: boolean;
     mapBoundary?: boolean;
     mergeSide?: boolean;
-    style?: 'map2Base' | 'map2CityOnMap';
-    bottomPlane?: boolean;
-    bottomPlaneWater?: boolean;
+    /** switchMapRegion 时重建城市建筑、道路、河流等数据层。 */
+    cityOnMap?: boolean;
+    /** 大洲背景使用地图原点，不按经纬度再次定位。 */
+    continentsBgAtOrigin?: boolean;
+    /** 代码初始化空地图时是否创建默认聚光灯。 */
     geojsonExtensions?: Record<string, GeoJSON_3 | string | number | (GeoJSON_3 | string | number)[]>;
     geojsonMapReplace?: Record<string, GeoJSON_3 | string | number>;
     extrudeLineGeojsonMapReplace?: Record<string, GeoJSON_3 | string | number>;
     shadowMap?: boolean;
     switchFixConfig?: SwitchFixConfig;
-    _currentAdcodes?: number[];
+    /** switchMapRegion 后按场景声明替换区域相关纹理。 */
+    regionTextureRules?: RegionTextureRule[];
+    /** 动态地图、城市数据和水面纹理的资源地址模板。 */
+    assetSources?: MapAssetSources;
+}
+
+export declare interface MapRegionBackInteraction {
+    trigger: 'click' | 'clickOutside';
+    objectId: string;
+    filter?: SceneInteractionFilter;
+    action: {
+        type: 'backMapRegion';
+    };
+}
+
+declare interface MapRegionEnterTransitionOptions extends SceneEnterTransitionOptions {
+    sourceCamera?: [number, number, number, number, number, number];
+}
+
+export declare type MapRegionSceneResolver = (document: VisSceneDocument, adcode: number) => string | SceneViewportDocument | null | undefined | Promise<string | SceneViewportDocument | null | undefined>;
+
+export declare interface MapRegionSwitchInteraction {
+    trigger: 'click';
+    objectId: string;
+    filter?: SceneInteractionFilter;
+    action: {
+        /** 先恢复目标层级模板，再把其中的地图切换到命中的行政区。 */
+        type: 'switchMapRegion';
+        sceneId: string;
+        adcode: 'clicked' | number;
+    };
+}
+
+/** 平台导出的运行时对象绑定，使用 Lead 的完整 key，不依赖命名规则。 */
+declare interface MapSceneBindings {
+    container: string;
+    region: {
+        adcode: number;
+        object: string;
+    };
+    parentBackgrounds: string[];
+    continentsBackground?: string;
+    cities: string[];
 }
 
 declare class Model extends GroupObject {
-    options: Options_4;
+    options: Options_7;
     mixer: THREE.AnimationMixer | null;
     clips: THREE.AnimationClip[];
     actions: THREE.AnimationAction[];
     actionStates: Record<string, boolean>;
     objectType: string;
-    constructor(options: Options_4);
+    constructor(options: Options_7);
     create(): Promise<void>;
     render(): void;
     /**
@@ -1057,8 +889,16 @@ declare class Mountain extends GroupObject {
     rebuildFromScene(): void;
 }
 
-declare interface Options {
-    sprite?: boolean;
+declare interface Options extends NonNullable<ConstructorParameters<typeof LineObject>[0]> {
+    from: number[];
+    to: number[];
+    control1?: number[];
+    control2?: number[];
+    radius?: number;
+    globe?: boolean;
+    color?: string;
+    lineWidth?: number;
+    offsetLoop?: boolean;
 }
 
 declare interface Options_10 {
@@ -1106,33 +946,13 @@ declare interface Options_13 {
     map?: THREE.Texture | null;
 }
 
-declare interface Options_2 extends NonNullable<ConstructorParameters<typeof LineObject>[0]> {
-    from: number[];
-    to: number[];
-    control1?: number[];
-    control2?: number[];
-    radius?: number;
-    globe?: boolean;
-    color?: string;
-    lineWidth?: number;
-    offsetLoop?: boolean;
-}
-
-declare interface Options_3 {
+declare interface Options_2 {
     path?: THREE.Curve<THREE.Vector3>;
     radius?: number;
     multiplyScalar?: number;
 }
 
-declare interface Options_4 {
-    src?: string;
-    autoPlay?: boolean;
-    playbackSpeed?: number;
-    serializedClips?: SerializedClip[];
-    playingClipNames?: string[];
-}
-
-declare interface Options_5 {
+declare interface Options_3 {
     uuid?: string;
     areaGroup?: boolean;
     geojson: GeoJSON_2;
@@ -1169,19 +989,32 @@ declare interface Options_5 {
     bloom?: boolean;
 }
 
-declare interface Options_6 {
+declare interface Options_4 {
     radius?: number;
     rotationY?: number;
 }
 
-declare interface Options_7 {
+declare interface Options_5 {
     radius?: number;
 }
 
+declare interface Options_6 {
+    sprite?: boolean;
+}
+
+declare interface Options_7 {
+    src?: string;
+    autoPlay?: boolean;
+    playbackSpeed?: number;
+    serializedClips?: SerializedClip[];
+    playingClipNames?: string[];
+}
+
 declare interface Options_8 {
     scale: number;
     depth: number;
     assetsPrefix?: string;
+    geojsonSource: string;
 }
 
 declare interface Options_9 {
@@ -1206,7 +1039,7 @@ declare class Plane extends MeshObject {
 
 declare class PlaneMap extends GroupObject {
     objectType: string;
-    options: Required<Omit<Options_5, 'bbox' | 'extrudeLineGeojson'>> & Pick<Options_5, 'bbox' | 'extrudeLineGeojson'>;
+    options: Required<Omit<Options_3, 'bbox' | 'extrudeLineGeojson'>> & Pick<Options_3, 'bbox' | 'extrudeLineGeojson'>;
     isActive: boolean;
     groupArr: GroupObject[];
     areaArr: ExtrudePolygonObject[];
@@ -1214,10 +1047,12 @@ declare class PlaneMap extends GroupObject {
     mergeSideArea: ExtrudePolygonObject | null;
     extrudelineArr?: LineObject[];
     splitPolygons: number;
-    constructor(options: Options_5);
+    constructor(options: Options_3);
     create(): Promise<void>;
+    private markGeneratedObjects;
     private ensureExtrudeLineMaterials;
     createExtrudeLines(): Promise<void>;
+    createLines(lineMaterial?: MeshLineMaterial, bgLineMaterial?: MeshLineMaterial): Promise<LineObject[]>;
     clearExtrudeLines(): void;
     syncExtrudeLines(hasExtrudeLine?: boolean): Promise<void>;
     mergeAreaSide(): Promise<void>;
@@ -1252,6 +1087,12 @@ declare class PlaneMap extends GroupObject {
     deactive(): void;
     render(): void;
     rebuildFromScene(): void;
+    private clearGeneratedRegionProperties;
+    /**
+     * 场景快照保存的是网格实际材质，options 中的 Material 会被导出器过滤。
+     * 恢复完成后从生成对象反推下一次区域重建所需的运行时材质。
+     */
+    private restoreMaterialOptionsFromScene;
     toggleExtrudelineBloom(s: boolean): void;
     active(): void;
     dispose(): void;
@@ -1264,8 +1105,8 @@ declare class PlaneShadow extends MeshObject {
 
 declare class Point extends BaseObject {
     objectType: string;
-    options: Options;
-    constructor(options: Options);
+    options: Options_6;
+    constructor(options: Options_6);
     get material(): THREE.MeshBasicMaterial | THREE.SpriteMaterial;
     getMaterial(): THREE.MeshBasicMaterial | THREE.SpriteMaterial;
     create(): Promise<void>;
@@ -1280,9 +1121,35 @@ declare class PointLight extends PointLightObject {
 }
 
 declare class RectAreaLight extends RectAreaLightObject {
-    render(): void;
 }
 
+declare interface RegionTextureRule {
+    /** mList 中的材质 key，例如 plane#topMat。 */
+    material: string;
+    /** THREE.Material 上的纹理属性，例如 map、emissiveMap。 */
+    property: string;
+    /** 资源地址模板，支持 {adcode} 和 {level} 占位符。 */
+    url?: string;
+    /** adcode 到资源地址的显式映射，优先级高于 url。 */
+    sources?: Record<string, string>;
+    /** 复用同一材质上另一个纹理槽位的图片。 */
+    copyFrom?: string;
+    /** 仅在指定地图展示层级应用。 */
+    levels?: string[];
+}
+
+export declare interface RemappedSceneDocument {
+    entrySceneId: string;
+    scenes: SceneViewportDocument[];
+    idMap: Map<string, string>;
+}
+
+/**
+ * 复制一组场景并为它们分配新 ID，同时保持文档内部的场景跳转关系。
+ * 用于把完整模板追加到另一个场景文档中。
+ */
+export declare function remapSceneDocumentIds(document: VisSceneDocument, createSceneId: (scene: SceneViewportDocument, index: number) => string): RemappedSceneDocument;
+
 declare class Ring extends MeshObject {
     objectType: string;
     create(): void;
@@ -1299,19 +1166,162 @@ declare class Road extends GroupObject {
     dispose(): void;
 }
 
-declare interface SelectedMeta {
+export declare const SCENE_DOCUMENT_FORMAT: "vis-scene";
+
+export declare const SCENE_DOCUMENT_SCHEMA_VERSION: 2;
+
+export declare interface SceneBackInteraction {
+    trigger: 'click' | 'clickOutside';
+    objectId: string;
+    filter?: SceneInteractionFilter;
+    action: {
+        type: 'back';
+    };
+}
+
+declare interface SceneControlsOptions {
+    mouseLeft?: number | boolean;
+    mouseRight?: number | boolean;
+    mouseWheel?: number | boolean;
+    mouseNone?: boolean;
+    viewportPadding?: [number, number, number, number];
+    autoRotateSpeed?: number;
+}
+
+export declare interface SceneDocumentMarker {
+    format: typeof SCENE_DOCUMENT_FORMAT;
+    schemaVersion: number;
+}
+
+declare interface SceneEnterTransitionOptions {
+    duration: number;
+    /** 动画初始状态布置完成后恢复渲染。 */
+    onPrepared?: () => void;
+}
+
+export declare type SceneInteraction = SceneSwitchInteraction | SceneBackInteraction | MapRegionSwitchInteraction | MapRegionBackInteraction;
+
+export declare interface SceneInteractionFilter {
+    mode: 'include' | 'exclude';
+    objectIds?: string[];
+    baseObjectTypes?: string[];
+}
+
+/**
+ * 管理一个多场景文档。所有场景共享同一个 Pencil/Renderer，场景实例按 id 缓存。
+ */
+export declare class SceneManager extends Event_2 {
+    private options;
+    private document?;
+    private runtimeHooks?;
+    private instances;
+    private currentSceneId;
+    private history;
+    private isSwitching;
+    private isRegionSwitching;
+    private pencil?;
+    private debugInteraction;
+    private enablePickDebug;
+    private disposeInactiveScenes;
+    constructor(options: SceneManagerInitOptions);
+    private captureCamera;
+    private playTransition;
+    /** 接管一个已经恢复完成的场景，供编辑器首次加载时复用。 */
+    attach(document: VisSceneDocument, sceneId: string, scene: Base): Base;
+    /** 更新可编辑文档，并释放已经不属于文档的非活动场景实例。 */
+    setDocument(document: VisSceneDocument): void;
+    load(documentOrUrl: VisSceneDocument | string, hooks?: Record<string, any>): Promise<Base>;
+    /**
+     * 以指定地图模板和行政区直接启动，不先加载文档配置的入口场景。
+     * 适用于宿主按路由或业务参数决定初始省、市、区的场景。
+     */
+    loadMapRegion(documentOrUrl: VisSceneDocument | string, sceneId: string, adcode: number, hooks?: Record<string, any>): Promise<Map_2>;
+    loadMapRegion(documentOrUrl: VisSceneDocument | string, adcode: number, resolveScene: MapRegionSceneResolver, hooks?: Record<string, any>): Promise<Map_2>;
+    private loadDocument;
+    switchScene(sceneId: string, options?: SwitchSceneOptions, hooks?: Record<string, any>): Promise<Base | null>;
+    /** 编辑器事务：在独立页面上修改参数并重建快照，成功后一起提交文档和实例。 */
+    editScene(sceneId: string, edit: (scene: Base, definition: SceneViewportDocument) => Promise<SceneViewportDocument>, hooks?: Record<string, any>): Promise<Base>;
+    back(hooks?: Record<string, any>): Promise<Base | null>;
+    /**
+     * 切到目标地图场景，并按 adcode 重建其中的地图。sceneId 不同时，语义等价于
+     * switchScene(sceneId) 后 switchMapRegion(adcode)，但候选场景只在两步都成功后提交，
+     * 避免显示模板原始行政区、播放两次动画或产生两条返回历史。
+     * 始终从文档基线构建隔离页面，避免对缓存实例反复施加缩放/删除修正。
+     * 旧页面在构建期间保持完整；只有所有资源、几何和交互就绪才提交导航。
+     */
+    switchMapRegion(sceneId: string, adcode: number, options?: SwitchSceneOptions, hooks?: Record<string, any>): Promise<Map_2 | null>;
+    /** 场景切换与区域切换共享一条返回历史。 */
+    backMapRegion(hooks?: Record<string, any>): Promise<Base | null>;
+    getCurrentSceneId(): string;
+    getCurrentScene<T extends SceneType>(type: T): SceneTypeMap[T] | null;
+    getCurrentScene(): Base | null;
+    private getCurrentSceneByType;
+    getScene<T extends SceneType>(sceneId: string, type: T): SceneTypeMap[T] | undefined;
+    getScene(sceneId: string): Base | undefined;
+    private getSceneByType;
+    getDocument(): VisSceneDocument | undefined;
+    private bindSceneInteractions;
+    canBack(): boolean;
+    private disposeInstances;
+    dispose(): void;
+}
+
+export declare interface SceneManagerBehaviorOptions {
+    /** 编辑器模式下设为 false，避免绑定运行时点击跳转。 */
+    bindInteractions?: boolean;
+    /** 输出射线命中和场景交互诊断，仅用于开发排查。 */
+    debugInteractions?: boolean;
+    /** 创建场景后、恢复 JSON 前调用。 */
+    prepareScene?: (scene: Base) => void;
+    /** 是否保留非活动场景实例；编辑器可关闭以限制 GPU/内存占用。 */
+    cacheScenes?: boolean;
+}
+
+export declare type SceneManagerInitOptions = SceneManagerOptions & SceneManagerBehaviorOptions;
+
+export declare interface SceneManagerOptions extends Pick<BaseOptions, 'container' | 'controlsContainer' | 'css2DContainer' | 'assetsPrefix' | 'pencilConfig' | 'logarithmicDepthBuffer' | 'tier' | 'observeParentScale'> {
+    /** 动态行政区数据访问使用的授权 key。 */
+    mapSwitchKey?: string;
+}
+
+export declare interface SceneSwitchInteraction {
+    trigger: 'click' | 'clickOutside';
+    objectId: string;
+    filter?: SceneInteractionFilter;
+    action: {
+        type: 'switchScene';
+        sceneId: string;
+    };
+}
+
+export declare interface SceneTransitionOptions {
+    type?: 'fade' | 'mapDrill';
+    duration?: number;
+}
+
+export declare type SceneType = keyof SceneTypeMap;
+
+export declare interface SceneTypeMap {
+    base: Base;
+    earth: Earth;
+    map: Map_2;
+}
+
+export declare interface SceneViewportDocument {
+    id: string;
     name: string;
-    key: string;
-    object: THREE.Mesh;
-    baseObject: BaseObject;
-    visible: boolean;
-    disabledC: boolean;
-    disabledR: boolean;
-    disabledTC: boolean;
-    disabledVisible: boolean;
-    children: SelectedMeta[];
+    interactions?: SceneInteraction[];
+    cs?: Record<string, number[]>;
+    csa?: string;
+    vis: {
+        type: string;
+        options: Record<string, any>;
+    };
+    scene: Record<string, any>;
 }
 
+export declare function selectSceneDocument(document: VisSceneDocument, sceneId: string): VisSceneDocument;
+
 declare type SerializedClip = ReturnType<(typeof THREE.AnimationClip)['toJSON']>;
 
 declare const sinusoidalInOut: ({ onUpdate, onComplete, backwards, }?: {
@@ -1338,8 +1348,8 @@ declare class Sphere extends MeshObject {
 
 declare class SphereShadow extends MeshObject {
     objectType: string;
-    options: Required<Options_7>;
-    constructor(options: Options_7);
+    options: Required<Options_5>;
+    constructor(options: Options_5);
     create(): Promise<void>;
     rebuildFromScene(): void;
 }
@@ -1371,14 +1381,21 @@ declare interface SwitchFixConfig {
     r?: string[];
 }
 
+export declare interface SwitchSceneOptions {
+    /** 返回历史时不再记录当前场景。 */
+    recordHistory?: boolean;
+    /** false 关闭动画；地图场景之间默认 mapDrill，其他场景默认 fade。 */
+    transition?: false | SceneTransitionOptions;
+}
+
 export { THREE }
 
 declare const timeOut: (ms: number) => Promise<any>;
 
 declare class Tube extends MeshObject {
     objectType: string;
-    options: Options_3;
-    constructor(options: Options_3);
+    options: Options_2;
+    constructor(options: Options_2);
     create(): void;
 }
 
@@ -1386,7 +1403,16 @@ export { TWEEN }
 
 export { Tween }
 
-export declare const VERSION = "0.31.33";
+export declare const VERSION = "0.32.0";
+
+export declare interface VisSceneDocument extends SceneDocumentMarker {
+    entrySceneId: string;
+    scenes: SceneViewportDocument[];
+    c?: Record<string, any>;
+    d?: Record<string, any>;
+    h?: Record<string, any>;
+    s?: string;
+}
 
 export { }