vis-core 0.30.14 → 0.31.0

package/dist/index.d.ts

@@ -1,32 +1,38 @@
+import { AmbientLightObject } from 'gl-draw';
 import { BaseObject } from 'gl-draw';
-import { ConicPolygon } from 'gl-draw';
 import { default as default_2 } from 'gl-draw';
+import { DirectionalLightObject } from 'gl-draw';
 import { EventEmitter } from 'events';
-import { ExtrudePolygon } from 'gl-draw';
+import { ExtrudePolygonObject } from 'gl-draw';
 import { FeatureCollection } from 'geojson';
 import { GeoJsonProperties } from 'geojson';
 import { GeoProjection } from 'd3-geo';
-import { Group } from 'gl-draw';
+import { GroupObject } from 'gl-draw';
+import { HemisphereLightObject } from 'gl-draw';
 import { Lead } from 'gl-draw';
-import { Light as Light_2 } from 'gl-draw';
-import { Line } from 'gl-draw';
-import { Line2 } from 'gl-draw';
+import { LineObject } from 'gl-draw';
 import { Listener } from 'events';
 import { MeshLineMaterial } from 'gl-draw';
+import { MeshObject } from 'gl-draw';
 import { MultiPolygon } from 'geojson';
-import { Node as Node_2 } from 'gl-draw';
+import { NodeObject } from 'gl-draw';
 import { PickFunctionsItem } from 'gl-draw';
+import { PointLightObject } from 'gl-draw';
 import { Polygon } from 'geojson';
 import { Position } from 'geojson';
+import { RectAreaLightObject } from 'gl-draw';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
+import { SpotLightObject } from 'gl-draw';
+import { SpriteObject } from 'gl-draw';
 import * as THREE from 'three';
 import { default as TWEEN } from 'three/examples/jsm/libs/tween.module.js';
 import { Tween } from 'three/examples/jsm/libs/tween.module.js';
 import { Water } from './Water2';
 
-export declare const access: {
-    token: string;
-};
+declare class AmbientLight extends AmbientLightObject {
+    constructor(...options: ConstructorParameters<typeof AmbientLightObject>);
+    render(): void;
+}
 
 export declare namespace animationUtils {
     export {
@@ -39,17 +45,23 @@ export declare namespace animationUtils {
     }
 }
 
-declare class Arc extends BaseObject {
-    options: Options_4;
-    line: Line;
+declare class Arc extends LineObject {
+    objectType: string;
+    options: Options_2;
     helperMeshPosition?: THREE.Vector3[];
-    constructor(options: Options_4);
-    static getInitOptions(pencil: default_2, options: Options_4): {
+    constructor(options: Options_2);
+    static getInitOptions(pencil: default_2, options: Options_2): {
         from: THREE.Vector3Tuple;
         to: THREE.Vector3Tuple;
     };
     create(): Promise<void>;
-    instantiate(ops?: any): Promise<this>;
+    instantiate(ops: Parameters<BaseObject['instantiate']>[0]): Promise<this>;
+    line: {
+        options: {
+            nodes: THREE.Vector3[];
+        };
+    };
+    private _tempCurve;
     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>;
@@ -64,81 +76,47 @@ declare class Arc extends BaseObject {
     }): void;
     update(): void;
     render(): void;
-    dispose(): void;
 }
 
-declare class Area extends BaseObject {
-    options: Options_10;
-    area: ExtrudePolygon[];
-    constructor(options: Options_10);
+declare class Area extends GroupObject {
+    objectType: string;
+    options: Options_7;
+    area: ExtrudePolygonObject[];
+    constructor(options: Options_7);
     create(): Promise<void>;
+    rebuildFromScene(): void;
 }
 
 export declare class Base extends Camera {
     static VisName: string;
+    private static _loadingCount;
     playing: boolean;
     leftTruck: boolean;
     options: BaseOptions;
     showState: boolean;
     settings: Record<string, any>;
-    delLoadArr?: string[];
     extendsOptions: Record<string, any>;
-    leadObjs: {
-        Plane: Plane;
-        CrossPlane: CrossPlane;
-        PlaneShadow: PlaneShadow;
-        Ring: Ring;
-        Sphere: Sphere;
-        Sprite: Sprite;
-        Tetrahedron: Tetrahedron;
-        Torus: Torus;
-        TorusKnot: TorusKnot;
-        Tube: Tube;
-        Box: Box;
-        Capsule: Capsule;
-        Circle: Circle;
-        Cylinder: Cylinder;
-        Dodecahedron: Dodecahedron;
-        Icosahedron: Icosahedron;
-        Lathe: Lathe;
-        Octahedron: Octahedron;
-        Node: typeof Node_2;
-        Line: typeof Line;
-        Line2: Line2;
-        ExtrudePolygon: ExtrudePolygon;
-        ConicPolygon: ConicPolygon;
-        Group: Group;
-        Light: Light;
-        Point: Point;
-        Arc: typeof Arc;
-        Model: Model;
-    };
-    lead: Lead<typeof objs>;
+    lead: Lead;
     mList: default_2['mList'];
     tier0: boolean;
     pmremGenerator: THREE.PMREMGenerator | null;
     re: RoomEnvironment | null;
     roomEnvMap?: THREE.Texture;
     visName: string;
-    editor?: Editor;
     publicDir: Record<string, string>;
     constructor(options: BaseOptions);
     private showDetectRes;
     setOptions(options: Record<string, any>): void;
-    _baseObjectByUuid: Editor['baseObjectByUuid'];
-    _objectByUuid: Editor['objectByUuid'];
-    get fromJSON(): (jsonOrUrl: Record<string, any> | string, hooks?: Record<string, any>) => Promise<Record<string, any>>;
-    get baseObjectByUuid(): {
-        (key: `arc${string}`): Arc;
-        (key: `sprite${string}`): Sprite;
-        (key: string): BaseObject;
-    };
-    get objectByUuid(): (key: string) => THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
-    get getDataURL(): () => string;
+    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 observeScale;
     initPencil(): Promise<void>;
     private sceneActive;
@@ -150,28 +128,78 @@ export declare class Base extends Camera {
     initSettingsObj?: Record<string, any>;
     mouseButtonsActiveStore: Record<string, any> | null;
     initSettings(): void;
-    handleSetting(key: string, value: any): Promise<any>;
+    handleSetting(key: string, value: any): void;
     show(): void;
     showAction(): void;
     hide(): void;
-    addGroup(): Promise<Group>;
+    exportScene(): any;
+    restoreScene(str: string, 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>;
+    getClassRefByType(type: string): typeof BaseObject;
+    addGroup(): Promise<GroupObject>;
     addCSS2D(dom: HTMLElement, options?: {
         display?: string;
         onTop?: number;
         target?: BaseObject;
-    }): Promise<Node_2>;
+    }): Promise<NodeObject>;
     addCSS3D(dom: HTMLElement, options?: {
         display?: string;
         onTop?: number;
         type?: '3d' | '3dSprite';
         target?: BaseObject;
-    }): Promise<Node_2>;
+    }): Promise<NodeObject>;
+    private addNode;
     getRoomEnvMap(): THREE.Texture<unknown>;
     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.Material[], THREE.Object3DEventMap> | undefined;
+    uuidByBaseObject(object: BaseObject): string | undefined;
+    baseObjectByUuid(key: `arc${string}`): Arc;
+    baseObjectByUuid(key: `sprite${string}`): Sprite;
+    baseObjectByUuid(key: string): BaseObject;
+    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;
 }
 
@@ -224,21 +252,23 @@ declare interface BaseOptions {
     pencil2?: any;
     pencilConfig?: Record<string, any>;
     disableInitShow?: boolean;
-    editor?: boolean;
     logarithmicDepthBuffer?: boolean;
     tier?: number;
     observeParentScale?: boolean;
     [key: string]: any;
 }
 
-declare class Box extends BaseObject {
+declare class Box extends MeshObject {
+    objectType: string;
     create(): void;
 }
 
-declare class Building extends BaseObject {
-    options: Options_8;
-    constructor(options: Options_8);
+declare class Building extends GroupObject {
+    objectType: string;
+    options: Options_5;
+    constructor(options: Options_5);
     create(): Promise<void>;
+    rebuildFromScene(): void;
     worldPositionZ: {
         value: number;
     };
@@ -250,6 +280,7 @@ declare class Camera extends Event_2 {
     container: HTMLElement;
     pencil: default_2;
     cameraState: Record<string, number[]>;
+    cameraStateActive: string;
     setSaveCamera(type: string): void;
     useSaveCamera(type: string, enableTransition?: boolean): Promise<boolean>;
     lookAt(positionX: number, positionY: number, positionZ: number, targetX: number, targetY: number, targetZ: number, enableTransition?: boolean, smoothTime?: number): Promise<void>;
@@ -263,64 +294,25 @@ declare class Camera extends Event_2 {
         polarAngle?: number;
         azimuthAngle?: number;
     }, enableTransition?: boolean, smoothTime?: number): Promise<void>;
-    paddingInCssPixel(box3OrBaseObject: BaseObject | THREE.Box3, top: number, right: number, bottom: number, left: number, enableTransition: boolean): Promise<void[]>;
+    paddingInCssPixel(obj: BaseObject, top: number, right: number, bottom: number, left: number, enableTransition: boolean): Promise<void[]>;
     resetCamera(enableTransition?: boolean, smoothTime?: number): Promise<void>;
     unproject(e: MouseEvent, targetZ?: number): THREE.Vector3;
     dispose(): void;
 }
 
-declare class Capsule extends BaseObject {
-    create(): void;
-}
-
-declare class Circle extends BaseObject {
+declare class Circle extends MeshObject {
+    objectType: string;
     create(): void;
 }
 
 export declare class City extends Base {
     static VisName: string;
-    leadObjs: {
-        Building: typeof Building;
-        Road: typeof Road;
-        Area: Area;
-        CityPlane: CityPlane;
-        Target: Target;
-        Plane: Plane;
-        CrossPlane: CrossPlane;
-        PlaneShadow: PlaneShadow;
-        Ring: Ring;
-        Sphere: Sphere;
-        Sprite: Sprite;
-        Tetrahedron: Tetrahedron;
-        Torus: Torus;
-        TorusKnot: TorusKnot;
-        Tube: Tube;
-        Box: Box;
-        Capsule: Capsule;
-        Circle: Circle;
-        Cylinder: Cylinder;
-        Dodecahedron: Dodecahedron;
-        Icosahedron: Icosahedron;
-        Lathe: Lathe;
-        Octahedron: Octahedron;
-        Node: Node_2;
-        Line: Line;
-        Line2: Line2;
-        ExtrudePolygon: ExtrudePolygon;
-        ConicPolygon: ConicPolygon;
-        Group: typeof Group;
-        Light: Light;
-        Point: Point;
-        Arc: Arc;
-        Model: Model;
-    };
-    lead: Lead<typeof objs_2>;
     adcode: number;
     pcenter: [number, number];
     pscale: number;
     projection: ReturnType<typeof getProjection>;
     options: CityOptions;
-    group: Group;
+    group: GroupObject;
     building: Building;
     road: Road;
     setOptions(options: CityOptions): void;
@@ -329,7 +321,8 @@ export declare class City extends Base {
     initMaterial(): Promise<void>;
     disableSSAO(): void;
     enabledSSAO(): void;
-    init(): Promise<void>;
+    initGroup(): Promise<void>;
+    beforeInit(): Promise<void>;
     getInvert(vector3: THREE.Vector3): [number, number] | null | undefined;
     fitTo(obj: BaseObject, enableTransition?: boolean): Promise<void>;
     initVis(): Promise<void>;
@@ -357,6 +350,35 @@ export declare class City extends Base {
         x: number;
         y: number;
     };
+    restoreScene(str: string, objectsMap?: {
+        Building: typeof Building;
+        Road: typeof Road;
+        Area: Area;
+        CityPlane: CityPlane;
+        Target: Target;
+        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;
+    }): Promise<void>;
+    rebuildFromScene(): Promise<void>;
 }
 
 declare class city extends City {
@@ -386,103 +408,46 @@ declare interface CityOptions extends BaseOptions {
     ssao?: boolean;
 }
 
-declare class CityPlane extends BaseObject {
-    options: Options_11;
-    constructor(options: Options_11);
+declare class CityPlane extends MeshObject {
+    objectType: string;
+    options: Options_8;
+    constructor(options: Options_8);
     plane: THREE.PlaneGeometry;
     water?: Water;
     create(): Promise<void>;
+    rebuildFromScene(): void;
     addWater(): void;
 }
 
-declare class Config {
-    editor: Editor;
-    meta: {
-        name: string;
-        key: string;
-        open: boolean;
-        jsonVersion: string;
-        sdkVersion: string;
-        __template: string;
-    };
-    constructor(editor: Editor);
-    setConfig<K extends keyof Config['meta']>(key: K, value: Config['meta'][K]): void;
-    fromJSON(json: any): void;
-    compareVersion(): void;
-    toJSON(): {
-        version: string;
-    };
-}
-
-declare class ContinentsBg extends BaseObject {
-    options: Options_15;
+declare class ContinentsBg extends GroupObject {
+    objectType: string;
+    options: Options_12;
     mapArr: PlaneMap[];
-    constructor(options: Options_15);
+    constructor(options: Options_12);
     create(): Promise<void>;
     private getPointInContinentInfo;
     getPointInContinent(location: [number, number]): boolean;
     getLocationPosition(location: [number, number], tName?: string): [number, number, number] | undefined;
     render(): void;
+    rebuildFromScene(): void;
     dispose(): void;
 }
 
-declare class CrossPlane extends BaseObject {
-    options: Options;
-    constructor(options: Options);
-    create(): Promise<void>;
-}
-
-declare class Cylinder extends BaseObject {
-    create(): void;
-}
-
-declare class Dodecahedron extends BaseObject {
-    create(): void;
+declare class DirectionalLight extends DirectionalLightObject {
+    constructor(...options: ConstructorParameters<typeof DirectionalLightObject>);
+    update(delta: number, elapsed: number): void;
+    render(): void;
 }
 
 export declare class Earth extends Base {
     static VisName: string;
-    leadObjs: {
-        Earth: Earth_2;
-        SphereShadow: SphereShadow;
-        Countries: typeof PlaneMap;
-        Plane: Plane;
-        CrossPlane: CrossPlane;
-        PlaneShadow: PlaneShadow;
-        Ring: Ring;
-        Sphere: Sphere;
-        Sprite: Sprite;
-        Tetrahedron: Tetrahedron;
-        Torus: Torus;
-        TorusKnot: TorusKnot;
-        Tube: Tube;
-        Box: Box;
-        Capsule: Capsule;
-        Circle: Circle;
-        Cylinder: Cylinder;
-        Dodecahedron: Dodecahedron;
-        Icosahedron: Icosahedron;
-        Lathe: Lathe;
-        Octahedron: Octahedron;
-        Node: Node_2;
-        Line: Line;
-        Line2: Line2;
-        ExtrudePolygon: ExtrudePolygon;
-        ConicPolygon: ConicPolygon;
-        Group: Group;
-        Light: Light;
-        Point: Point;
-        Arc: Arc;
-        Model: Model;
-    };
     leftTruck: boolean;
-    lead: Lead<typeof objs_3>;
     options: Required<EarthOptions>;
     extendsOptions: Record<string, any>;
     map: PlaneMap;
-    get mapArea(): ExtrudePolygon[];
+    get mapArea(): ExtrudePolygonObject[];
     setOptions(options: EarthOptions): void;
-    handleSetting(key: string, value: any): Promise<any>;
+    handleSetting(key: string, value: any): void;
     show(): void;
     animationIn(): void;
     initLight(): Promise<void>;
@@ -510,12 +475,42 @@ export declare class Earth extends Base {
      * @param upAxis - 物体的up轴方向，默认为Y轴 [0, 1, 0]
      */
     setObjectOnSphere(baseObject: BaseObject, location: [number, number], height?: number, upAxis?: [number, number, number]): void;
+    restoreScene(str: string, objectsMap?: {
+        Earth: Earth_2;
+        SphereShadow: SphereShadow;
+        Countries: typeof PlaneMap;
+        PlaneMap: typeof PlaneMap;
+        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: GroupObject;
+    }): Promise<void>;
+    rebuildFromScene(): Promise<void>;
 }
 
 declare class Earth_2 extends Sphere {
-    options: Required<Options_12>;
-    constructor(options: Options_12);
+    objectType: string;
+    options: Required<Options_10>;
+    constructor(options: Options_10);
     create(): void;
+    rebuildFromScene(): void;
 }
 
 declare interface EarthOptions extends BaseOptions {
@@ -527,66 +522,6 @@ declare interface EarthOptions extends BaseOptions {
     style?: 'chinaPlate' | 'countryPlate' | 'base';
 }
 
-declare class Editor {
-    selected: BaseObject | null;
-    playing: boolean;
-    currentMaterialSlot: number;
-    events: EventEmitter;
-    history: History_2;
-    viewport: Viewport;
-    hooks: Hooks;
-    config: Config;
-    pencil: default_2;
-    on: (type: string | number, listener: Listener) => EventEmitter;
-    emit: (type: string | number, ...args: any[]) => boolean;
-    options: Options_7;
-    constructor(options: Options_7);
-    getObjectMaterial(object?: THREE.Mesh | null, slot?: number): THREE.Material | THREE.Material[] | undefined;
-    getMListFixBaseObjectByObject(object: THREE.Mesh, slot: number): any;
-    materialObjectByUuid(uuid: string): any;
-    uuidByMaterialObject(object: THREE.Object3D): any;
-    setObjectMaterial(object: THREE.Mesh, slot: number, newMaterial: THREE.Material): void;
-    uuidByObject(object: THREE.Object3D): string | undefined;
-    objectByUuid(key: string): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
-    uuidByBaseObject(object: BaseObject): string | undefined;
-    baseObjectByUuid(key: `arc${string}`): Arc;
-    baseObjectByUuid(key: `sprite${string}`): Sprite;
-    baseObjectByUuid(key: string): BaseObject;
-    baseObjectByName(name: string): BaseObject | 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;
-    execute(cmd: any, optionalName?: string): Promise<void>;
-    private static urlCache;
-    private static _loadingCount;
-    /**
-     * 清除特定 URL 的缓存
-     * @param url 要清除的 URL，如果不提供则清除所有缓存
-     */
-    static clearUrlCache(url?: string): void;
-    fromJSON(jsonOrUrl: Record<string, any> | string, hooks?: Record<string, any>): Promise<Record<string, any>>;
-    appendJSON(jsonOrUrl: Record<string, any> | string): Promise<void>;
-    toJSON(): {};
-    select(...args: any[]): void;
-    setViewportVis(...args: any[]): void;
-    getDataURL(): string;
-    _dispose: boolean;
-    dispose(): void;
-}
-
 declare class Event_2 {
     event: EventEmitter;
     private eventHandlers;
@@ -635,17 +570,10 @@ export declare const getCityConfig: (adcode: number) => {
     jsonName: string;
 };
 
-/**
- * 获取地图配置
- * @param adcode 区域代码
- * @param options 配置选项
- */
-export declare const getMapConfig: (adcode: number, options?: MapConfigOptions) => Promise<any>;
-
 declare const getProjection: (options: {
     center: [number, number];
     scale: number;
-    projectionType?: "equirectangular" | "mercator" | "winkel3";
+    projectionType?: "mercator" | "equirectangular" | "winkel3";
     translate?: [number, number];
     precision?: number;
     rotate?: [number, number];
@@ -654,162 +582,26 @@ declare const getProjection: (options: {
 declare const getProjection_2: (options: {
     center: [number, number];
     scale: number;
-    projectionType?: "equirectangular" | "mercator" | "winkel3";
+    projectionType?: "mercator" | "equirectangular" | "winkel3";
     translate?: [number, number];
     precision?: number;
     rotate?: [number, number];
 }) => GeoProjection;
 
-declare class History_2 {
-    editor: Editor;
-    undos: any[];
-    redos: any[];
-    lastCmdTime: number;
-    idCounter: number;
-    historyDisabled: boolean;
-    constructor(editor: Editor);
-    /**
-     * 检查两个命令是否可以合并
-     */
-    private canMergeCommands;
-    execute(cmd: any, optionalName?: string): Promise<void>;
-    undo(): any;
-    redo(): any;
-    /**
-     * 处理图片数据，将ArrayBuffer转换为Base64字符串并建立引用映射
-     */
-    private processImageData;
-    /**
-     * 处理包含图片的命令
-     */
-    private processCommandWithImages;
-    toJSON(): {
-        u: any[];
-        i: Record<string, string>;
-    };
-    /**
-     * 处理图片引用，将引用字符串还原为实际URL或数据
-     */
-    private processImageReference;
-    /**
-     * 还原包含图片的命令数据
-     */
-    private restoreCommandImages;
-    /**
-     * 验证和规范化命令类型
-     */
-    private normalizeCommandType;
-    /**
-     * 创建命令实例
-     */
-    private createCommand;
-    fromJSON(json: any): void;
-    /**
-     * 批量处理撤销操作，支持分帧执行以避免阻塞UI
-     */
-    processUndos(maxFrameTime?: number): Promise<string>;
-    /**
-     * 执行单个撤销命令
-     */
-    private executeUndo;
-    /**
-     * 清空所有历史记录
-     */
-    clear(): void;
-    /**
-     * 获取历史记录状态信息
-     */
-    getState(): {
-        undoCount: number;
-        redoCount: number;
-        canUndo: boolean;
-        canRedo: boolean;
-        isDisabled: boolean;
-    };
-    /**
-     * 启用/禁用历史记录功能
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * 获取最后执行的命令
-     */
-    getLastCommand(): any;
-}
-
-declare class Hooks {
-    editor: Editor;
-    events: {
-        beforeSetVisOptions: Function[];
-        afterSetVisOptions: Function[];
-        beforeExecuteUndo: Function[];
-        afterExecuteUndo: Function[];
-        beforeShow: Function[];
-        afterShow: Function[];
-        beforeFromJSON: Function[];
-        afterFromJSON: Function[];
-        errorFromJSON: Function[];
-    };
-    source: string;
-    constructor(editor: Editor);
-    addEvents(event: Record<string, Function>): void;
-    addStaticEvents(func: Function): void;
-    fromJSON(source: string): void;
-    toJSON(): string;
-    clear(): void;
-    dispatch(type: keyof Hooks['events'], ...args: any[]): Promise<any>;
-}
-
-declare class Icosahedron extends BaseObject {
-    create(): void;
-}
-
-declare class Lathe extends BaseObject {
-    create(): void;
-}
-
-declare class Light extends Light_2 {
-    constructor(options: any);
-    update(delta: number, elapsed: number): void;
+declare class HemisphereLight extends HemisphereLightObject {
     render(): void;
 }
 
+/**
+ * 加载模板纹理图片，直接返回图片用于设置到材质上
+ */
+export declare const loadTemplateImages: (templateId: string, adcode: number, base?: string, customTemplateConfigs?: Record<string, TemplateConfig>) => Promise<{
+    map?: HTMLImageElement;
+    emissiveMap?: HTMLImageElement;
+}>;
+
 declare class Map_2 extends Base {
     static VisName: string;
-    leadObjs: {
-        PlaneMap: typeof PlaneMap;
-        CityPlane: CityPlane;
-        ContinentsBg: typeof ContinentsBg;
-        Mountain: PlaneMap_2;
-        Plane: Plane;
-        CrossPlane: CrossPlane;
-        PlaneShadow: PlaneShadow;
-        Ring: Ring;
-        Sphere: Sphere;
-        Sprite: Sprite;
-        Tetrahedron: Tetrahedron;
-        Torus: Torus;
-        TorusKnot: TorusKnot;
-        Tube: Tube;
-        Box: Box;
-        Capsule: Capsule;
-        Circle: Circle;
-        Cylinder: Cylinder;
-        Dodecahedron: Dodecahedron;
-        Icosahedron: Icosahedron;
-        Lathe: Lathe;
-        Octahedron: Octahedron;
-        Node: Node_2;
-        Line: Line;
-        Line2: Line2;
-        ExtrudePolygon: typeof ExtrudePolygon;
-        ConicPolygon: ConicPolygon;
-        Group: typeof Group;
-        Light: Light;
-        Point: Point;
-        Arc: Arc;
-        Model: Model;
-    };
-    lead: Lead<typeof objs_4>;
     options: Required<MapCityOptions>;
     mapHistory: {
         map: PlaneMap;
@@ -858,14 +650,14 @@ declare class Map_2 extends Base {
         c: number[];
         b: number[];
     };
-    get mapArea(): ExtrudePolygon[];
-    get mapLine(): Line[];
+    get mapArea(): ExtrudePolygonObject[];
+    get mapLine(): LineObject[];
     get adcodes(): number[];
     activePlaneMap: PlaneMap | null;
     isAnimating: boolean;
     parentBg: PlaneMap[];
     continentsBg?: ContinentsBg;
-    group: Group;
+    group: GroupObject;
     projection: ReturnType<typeof getProjection_2>;
     pcenter: [number, number];
     pscale: number;
@@ -873,13 +665,13 @@ declare class Map_2 extends Base {
     cityVis: city[];
     extendsOptions: Record<string, any>;
     setOptions(options: MapOptions): void;
-    initSettingsObj: Record<string, any>;
-    handleSetting(key: string, value: any): Promise<any>;
-    init(): Promise<void>;
+    initGroup(): Promise<void>;
+    beforeInit(): Promise<void>;
+    afterInit(): Promise<void>;
     initCityVis(adcode: number, grey?: boolean): Promise<city>;
     initCityOnMap(adcode: number): Promise<void>;
     initVisBg(): Promise<void>;
-    initVis(adcode: number): Promise<void>;
+    initVis(): Promise<void>;
     loaderAddBg(): void;
     initMaterialBg(): Promise<void>;
     consoleMousePostion(): void;
@@ -905,15 +697,12 @@ declare class Map_2 extends Base {
     caId: string | number | undefined;
     showAction(): Promise<void>;
     hide(): Promise<void>;
-    shadowMapLight?: BaseObject;
-    planeShadow?: BaseObject;
     shadowMapEnabled(): Promise<void>;
-    shadowMapDisabled(): void;
     getOptionsDepth(adcode: number): number;
     getDepth(adcode: number, futureBox: number[]): number;
     getReferenceScale(bboxa: number[], bboxb: number[]): number;
     getAdcodeShowLevel(adcode: number, fix?: boolean): string | undefined;
-    handleClick(area?: ExtrudePolygon): void;
+    handleClick(area?: ExtrudePolygonObject): void;
     beforeShowMap(adcodes: number[]): boolean;
     getAdcodes(adcode: number): number[];
     showMap({ adcode, adcodes: prevAdcodes, duration, }: {
@@ -937,14 +726,12 @@ declare class Map_2 extends Base {
         x: number;
         y: number;
     } | undefined;
-    booleanPointInCn(location: [number, number]): boolean;
     /**
      * 判断经纬度是否在当前地图板块内
      * @param location - 经纬度坐标 [经度, 纬度]
-     * @param adcode - 可选，指定板块的行政区划代码，不传则使用当前地图的adcode
      * @returns 是否在板块内
      */
-    booleanPointInMap(location: [number, number], adcode?: number): boolean;
+    booleanPointInMap(location: [number, number]): boolean;
     private getGeojson;
     handleDrillDown({ adcode, duration, handleLook, saveBackCamvasState, extrudelineBloom, }: {
         adcode: number;
@@ -955,19 +742,18 @@ declare class Map_2 extends Base {
     }): Promise<void>;
     saveCamvasState(type: 'userControls' | 'controls', index: number): void;
     fixNear(adcode: number): void;
-    fitTo(baseObject?: BaseObject, { polarAngle, azimuthAngle, referenceAngle, position, z, handleStart, adcode, enableTransition, }?: {
+    fitTo(obj?: BaseObject, { polarAngle, azimuthAngle, referenceAngle, z, handleStart, adcode, enableTransition, }?: {
         adcode?: number;
         polarAngle?: number;
         azimuthAngle?: number;
         referenceAngle?: [number, number, number, number, number, number];
         enableTransition?: boolean;
-        position?: [number, number, number];
         z?: number;
         handleStart?: () => void;
     }): Promise<void>;
     drawPlaneMap({ geojson, extrudeLineGeojson, bbox, depth, extrudelineBloom, adcode, }: {
-        geojson: GeoJSON_4;
-        extrudeLineGeojson?: GeoJSON_4;
+        geojson: GeoJSON_3;
+        extrudeLineGeojson?: GeoJSON_3;
         bbox?: number[];
         depth: number;
         adcode: number;
@@ -995,6 +781,60 @@ declare class Map_2 extends Base {
         c: number[];
         b: number[];
     } | undefined;
+    /**
+     * 根据目标 adcode 更新 options 中依赖 adcode 的字段
+     */
+    private updateOptionsForAdcode;
+    /**
+     * 根据当前 options.center 重新计算投影
+     */
+    private updateProjection;
+    rebuildFromScene(): Promise<void>;
+    /**
+     * 快照：捕获 PlaneMap 上用户添加的叠加对象
+     */
+    private captureOverlayLayers;
+    private captureObjectMaterialKeys;
+    /**
+     * 根据快照在 PlaneMap 上恢复叠加层
+     */
+    private applyOverlayLayers;
+    private _templateAdcode;
+    /**
+     * 根据 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;
 }
 export { Map_2 as Map }
@@ -1013,20 +853,6 @@ declare interface MapCityOptions extends MapOptions {
     citySSAO?: boolean;
 }
 
-/**
- * 地图配置选项接口
- */
-export declare interface MapConfigOptions {
-    /** 基础URL */
-    base?: string;
-    /** 之前的配置 */
-    prevConfig?: any;
-    /** 图像数组 */
-    imgArr?: string[] | Record<string, string>;
-    /** 自定义模板配置，会与默认配置合并 */
-    customTemplateConfigs?: Record<string, TemplateConfig>;
-}
-
 export declare interface MapEventHandlers {
     [key: string]: (...args: any[]) => void;
 }
@@ -1073,6 +899,7 @@ export declare class MapManager {
         b: number[];
     } | undefined;
     static extendsAdcodeAll: (cb: any) => void;
+    key: string;
     constructor(config: MapManagerConfig);
     /**
      * 设置事件处理器
@@ -1098,10 +925,6 @@ export declare class MapManager {
      * 创建地图实例
      */
     private createMapInstance;
-    /**
-     * 应用地图修复配置
-     */
-    private applyFixConfig;
     /**
      * 绑定区域交互事件
      */
@@ -1142,6 +965,7 @@ export declare class MapManager {
 }
 
 export declare interface MapManagerConfig {
+    key?: string;
     container: HTMLDivElement;
     controlsContainer?: HTMLDivElement;
     assetsPrefix?: string;
@@ -1165,8 +989,6 @@ declare interface MapOptions extends BaseOptions {
     mapDepth?: number[];
     depthReference?: number[];
     mapPadding?: number[];
-    geojsonMap?: Record<string, GeoJSON_4>;
-    extrudeLineGeojsonMap?: Record<string, GeoJSON_4>;
     fixGeojson?: Record<string, string>;
     plateInCenter?: boolean;
     clickHandleDrillDown?: boolean;
@@ -1194,16 +1016,19 @@ declare interface MapOptions extends BaseOptions {
     style?: 'map2Base' | 'map2CityOnMap';
     bottomPlane?: boolean;
     bottomPlaneWater?: boolean;
-    geojsonExtensions?: Record<string, GeoJSON_4 | string | number | (GeoJSON_4 | string | number)[]>;
+    geojsonExtensions?: Record<string, GeoJSON_3 | string | number | (GeoJSON_3 | string | number)[]>;
+    shadowMap?: boolean;
+    switchFixConfig?: SwitchFixConfig;
 }
 
-declare class Model extends BaseObject {
-    options: Options_5;
+declare class Model extends GroupObject {
+    options: Options_4;
     mixer: THREE.AnimationMixer | null;
     clips: THREE.AnimationClip[];
     actions: THREE.AnimationAction[];
     actionStates: Record<string, boolean>;
-    constructor(options: Options_5);
+    objectType: string;
+    constructor(options: Options_4);
     create(): Promise<void>;
     render(): void;
     /**
@@ -1258,144 +1083,19 @@ declare class Model extends BaseObject {
     dispose(): void;
 }
 
-declare const objs: {
-    Plane: typeof Plane;
-    CrossPlane: typeof CrossPlane;
-    PlaneShadow: typeof PlaneShadow;
-    Ring: typeof Ring;
-    Sphere: typeof Sphere;
-    Sprite: typeof Sprite;
-    Tetrahedron: typeof Tetrahedron;
-    Torus: typeof Torus;
-    TorusKnot: typeof TorusKnot;
-    Tube: typeof Tube;
-    Box: typeof Box;
-    Capsule: typeof Capsule;
-    Circle: typeof Circle;
-    Cylinder: typeof Cylinder;
-    Dodecahedron: typeof Dodecahedron;
-    Icosahedron: typeof Icosahedron;
-    Lathe: typeof Lathe;
-    Octahedron: typeof Octahedron;
-    Node: typeof Node_2;
-    Line: typeof Line;
-    Line2: typeof Line2;
-    ExtrudePolygon: typeof ExtrudePolygon;
-    ConicPolygon: typeof ConicPolygon;
-    Group: typeof Group;
-    Light: typeof Light;
-    Point: typeof Point;
-    Arc: typeof Arc;
-    Model: typeof Model;
-};
-
-declare const objs_2: {
-    Building: typeof Building;
-    Road: typeof Road;
-    Area: typeof Area;
-    CityPlane: typeof CityPlane;
-    Target: typeof Target;
-    Plane: Plane;
-    CrossPlane: CrossPlane;
-    PlaneShadow: PlaneShadow;
-    Ring: Ring;
-    Sphere: Sphere;
-    Sprite: Sprite;
-    Tetrahedron: Tetrahedron;
-    Torus: Torus;
-    TorusKnot: TorusKnot;
-    Tube: Tube;
-    Box: Box;
-    Capsule: Capsule;
-    Circle: Circle;
-    Cylinder: Cylinder;
-    Dodecahedron: Dodecahedron;
-    Icosahedron: Icosahedron;
-    Lathe: Lathe;
-    Octahedron: Octahedron;
-    Node: Node_2;
-    Line: Line;
-    Line2: Line2;
-    ExtrudePolygon: ExtrudePolygon;
-    ConicPolygon: ConicPolygon;
-    Group: Group;
-    Light: Light;
-    Point: Point;
-    Arc: Arc;
-    Model: Model;
-};
-
-declare const objs_3: {
-    Earth: typeof Earth_2;
-    SphereShadow: typeof SphereShadow;
-    Countries: typeof PlaneMap;
-    Plane: Plane;
-    CrossPlane: CrossPlane;
-    PlaneShadow: PlaneShadow;
-    Ring: Ring;
-    Sphere: Sphere;
-    Sprite: Sprite;
-    Tetrahedron: Tetrahedron;
-    Torus: Torus;
-    TorusKnot: TorusKnot;
-    Tube: Tube;
-    Box: Box;
-    Capsule: Capsule;
-    Circle: Circle;
-    Cylinder: Cylinder;
-    Dodecahedron: Dodecahedron;
-    Icosahedron: Icosahedron;
-    Lathe: Lathe;
-    Octahedron: Octahedron;
-    Node: Node_2;
-    Line: Line;
-    Line2: Line2;
-    ExtrudePolygon: ExtrudePolygon;
-    ConicPolygon: ConicPolygon;
-    Group: Group;
-    Light: Light;
-    Point: Point;
-    Arc: Arc;
-    Model: Model;
-};
-
-declare const objs_4: {
-    PlaneMap: typeof PlaneMap;
-    CityPlane: typeof CityPlane;
-    ContinentsBg: typeof ContinentsBg;
-    Mountain: typeof PlaneMap_2;
-    Plane: Plane;
-    CrossPlane: CrossPlane;
-    PlaneShadow: PlaneShadow;
-    Ring: Ring;
-    Sphere: Sphere;
-    Sprite: Sprite;
-    Tetrahedron: Tetrahedron;
-    Torus: Torus;
-    TorusKnot: TorusKnot;
-    Tube: Tube;
-    Box: Box;
-    Capsule: Capsule;
-    Circle: Circle;
-    Cylinder: Cylinder;
-    Dodecahedron: Dodecahedron;
-    Icosahedron: Icosahedron;
-    Lathe: Lathe;
-    Octahedron: Octahedron;
-    Node: Node_2;
-    Line: Line;
-    Line2: Line2;
-    ExtrudePolygon: ExtrudePolygon;
-    ConicPolygon: ConicPolygon;
-    Group: Group;
-    Light: Light;
-    Point: Point;
-    Arc: Arc;
-    Model: Model;
-};
-
-declare class Octahedron extends BaseObject {
-    create(): void;
+declare class Mountain extends GroupObject {
+    objectType: string;
+    options: Required<Omit<Options_13, 'bbox'>> & Pick<Options_13, 'bbox'>;
+    extrudePolygon: ExtrudePolygonObject;
+    constructor(options: Options_13);
+    geojson2Meta(geojson: GeoJSON_4): {
+        coords: Position[][];
+        properties: GeoJsonProperties;
+    }[];
+    create(): Promise<void>;
+    setNoise(geometry: THREE.BufferGeometry, image: HTMLImageElement, maxHeight?: number): void;
+    render(): void;
+    rebuildFromScene(): void;
 }
 
 declare interface Opt {
@@ -1403,80 +1103,25 @@ declare interface Opt {
 }
 
 declare interface Options {
-    material?: THREE.Material;
-    key?: string;
+    sprite?: boolean;
 }
 
 declare interface Options_10 {
-    jsonUrl: string;
-    projection: {
-        center: [number, number];
-        scale: number;
-    };
-    material: THREE.Material;
-    type: string;
-    cacheKey?: string;
-    oArr?: number[];
-}
-
-declare interface Options_11 {
-    width: number;
-    height: number;
-    material?: THREE.Material;
-    color?: string;
-    map?: THREE.Texture | null;
-}
-
-declare interface Options_12 {
     radius?: number;
     rotationY?: number;
 }
 
-declare interface Options_13 {
+declare interface Options_11 {
     radius?: number;
 }
 
-declare interface Options_14 {
-    areaGroup?: boolean;
-    geojson: GeoJSON_2;
-    projection?: {
-        center: [number, number];
-        scale: number;
-        rotate?: [number, number];
-        projectionType?: 'mercator' | 'equirectangular' | 'winkel3';
-    };
-    extrudeLineGeojson?: GeoJSON_2;
-    hasSide?: boolean;
-    hasTop?: boolean;
-    mergeSide?: boolean;
-    hasLine?: boolean;
-    start?: number;
-    depth?: number;
-    lineOffset?: number;
-    bbox?: number[];
-    topSegments?: number;
-    conic?: boolean;
-    materialOptions: {
-        topMat: THREE.Material;
-        sideMat?: THREE.Material;
-        lineMat?: MeshLineMaterial;
-        extrudeLineMat?: MeshLineMaterial;
-        bgTopMat?: THREE.Material;
-        bgSideMat?: THREE.Material;
-        bgLineMat?: MeshLineMaterial;
-        bgExtrudeLineMat?: MeshLineMaterial;
-    };
-    onTop?: number;
-    bloom?: boolean;
-}
-
-declare interface Options_15 {
+declare interface Options_12 {
     scale: number;
     depth: number;
 }
 
-declare interface Options_16 {
-    geojson: GeoJSON_3;
+declare interface Options_13 {
+    geojson: GeoJSON_4;
     projection: {
         center: [number, number];
         scale: number;
@@ -1487,44 +1132,32 @@ declare interface Options_16 {
     bbox?: number[];
 }
 
-declare interface Options_2 {
-    path?: THREE.Curve<THREE.Vector3>;
-    radius?: number;
-    multiplyScalar?: number;
-}
-
-declare interface Options_3 {
-    sprite?: boolean;
-}
-
-declare interface Options_4 {
+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;
-    key?: string;
 }
 
-declare interface Options_5 {
+declare interface Options_3 {
+    path?: THREE.Curve<THREE.Vector3>;
+    radius?: number;
+    multiplyScalar?: number;
+}
+
+declare interface Options_4 {
     src?: string;
     autoPlay?: boolean;
     playbackSpeed?: number;
 }
 
-declare interface Options_6 {
-    visFactories?: Base;
-}
-
-declare interface Options_7 {
-    visFactories?: Base;
-    assetsPrefix?: string;
-    processUndosMaxFrameTime?: number;
-}
-
-declare interface Options_8 {
+declare interface Options_5 {
+    uuid?: string;
     jsonUrl: string;
     projection: {
         center: [number, number];
@@ -1538,7 +1171,8 @@ declare interface Options_8 {
     grey?: boolean;
 }
 
-declare interface Options_9 {
+declare interface Options_6 {
+    uuid?: string;
     jsonUrl: string;
     projection: {
         center: [number, number];
@@ -1549,20 +1183,78 @@ declare interface Options_9 {
     grey?: boolean;
 }
 
-declare class Plane extends BaseObject {
+declare interface Options_7 {
+    uuid?: string;
+    jsonUrl: string;
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    material: THREE.Material;
+    type: string;
+    cacheKey?: string;
+    oArr?: number[];
+}
+
+declare interface Options_8 {
+    width: number;
+    height: number;
+    material?: THREE.Material;
+    color?: string;
+    map?: THREE.Texture | null;
+}
+
+declare interface Options_9 {
+    uuid?: string;
+    areaGroup?: boolean;
+    geojson: GeoJSON_2;
+    projection?: {
+        center: [number, number];
+        scale: number;
+        rotate?: [number, number];
+        projectionType?: 'mercator' | 'equirectangular' | 'winkel3';
+    };
+    extrudeLineGeojson?: GeoJSON_2;
+    hasSide?: boolean;
+    hasTop?: boolean;
+    mergeSide?: boolean;
+    hasLine?: boolean;
+    start?: number;
+    depth?: number;
+    lineOffset?: number;
+    bbox?: number[];
+    topSegments?: number;
+    conic?: boolean;
+    materialOptions: {
+        topMat: THREE.Material;
+        sideMat?: THREE.Material;
+        lineMat?: MeshLineMaterial;
+        extrudeLineMat?: MeshLineMaterial;
+        bgTopMat?: THREE.Material;
+        bgSideMat?: THREE.Material;
+        bgLineMat?: MeshLineMaterial;
+        bgExtrudeLineMat?: MeshLineMaterial;
+    };
+    onTop?: number;
+    bloom?: boolean;
+}
+
+declare class Plane extends MeshObject {
+    objectType: string;
     create(): void;
 }
 
-declare class PlaneMap extends BaseObject {
-    options: Required<Omit<Options_14, 'bbox' | 'extrudeLineGeojson'>> & Pick<Options_14, 'bbox' | 'extrudeLineGeojson'>;
+declare class PlaneMap extends GroupObject {
+    objectType: string;
+    options: Required<Omit<Options_9, 'bbox' | 'extrudeLineGeojson'>> & Pick<Options_9, 'bbox' | 'extrudeLineGeojson'>;
     isActive: boolean;
-    groupArr: Group[];
-    areaArr: ExtrudePolygon[];
-    lineArr: Line[];
-    mergeSideArea: ExtrudePolygon | null;
-    extrudelineArr?: Line[];
+    groupArr: GroupObject[];
+    areaArr: ExtrudePolygonObject[];
+    lineArr: LineObject[];
+    mergeSideArea: ExtrudePolygonObject | null;
+    extrudelineArr?: LineObject[];
     splitPolygons: number;
-    constructor(options: Options_14);
+    constructor(options: Options_9);
     create(): Promise<void>;
     addArea(geojson: GeoJSON_2, options: {
         material: THREE.Material | THREE.Material[];
@@ -1572,19 +1264,19 @@ declare class PlaneMap extends BaseObject {
         hasTop?: boolean;
         onTop?: number;
         castShadow?: boolean;
-    }): Promise<ExtrudePolygon[]>;
+    }): Promise<ExtrudePolygonObject[]>;
     addLine(geojson: GeoJSON_2, options: {
         material?: MeshLineMaterial;
         onTop?: number;
         areaGroup?: boolean;
-    }): Promise<Line[]>;
+    }): Promise<LineObject[]>;
     getPropertiesKey(properties: Record<string, any>): string;
     geojson2Meta(geojson: GeoJSON_2): {
         coords: Position[][];
         properties: GeoJsonProperties;
     }[];
     update(delta: number, elapsed: number): void;
-    findGroup(adcode: string | number, fix?: boolean): Group | undefined;
+    findGroup(adcode: string | number, fix?: boolean): GroupObject | undefined;
     setAreaMaterial(key: string, material: THREE.Material[] | THREE.Material): void;
     useAreaMaterial(key: string): void;
     setLineMaterial(key: string, material: THREE.Material): void;
@@ -1597,55 +1289,51 @@ declare class PlaneMap extends BaseObject {
     }): void;
     deactive(): void;
     render(): void;
+    rebuildFromScene(): void;
     toggleExtrudelineBloom(s: boolean): void;
     active(): void;
     dispose(): void;
 }
 
-declare class PlaneMap_2 extends BaseObject {
-    options: Required<Omit<Options_16, 'bbox'>> & Pick<Options_16, 'bbox'>;
-    extrudePolygon: ExtrudePolygon;
-    constructor(options: Options_16);
-    geojson2Meta(geojson: GeoJSON_3): {
-        coords: Position[][];
-        properties: GeoJsonProperties;
-    }[];
-    create(): Promise<void>;
-    setNoise(geometry: THREE.BufferGeometry, image: HTMLImageElement, maxHeight?: number): void;
-    render(): void;
-    dispose(): void;
-}
-
-declare class PlaneShadow extends BaseObject {
+declare class PlaneShadow extends MeshObject {
+    objectType: string;
     create(): Promise<void>;
 }
 
 declare class Point extends BaseObject {
-    options: Options_3;
-    constructor(options: Options_3);
-    get material(): THREE.SpriteMaterial | THREE.MeshBasicMaterial;
-    getMaterial(): THREE.SpriteMaterial | THREE.MeshBasicMaterial;
+    objectType: string;
+    options: Options;
+    constructor(options: Options);
+    get material(): THREE.MeshBasicMaterial | THREE.SpriteMaterial;
+    getMaterial(): THREE.MeshBasicMaterial | THREE.SpriteMaterial;
     create(): Promise<void>;
     scaleValue: number;
     setScale(n: number): void;
 }
 
-/**
- * 移除摄像机历史记录
- * @param u 历史记录数组
- */
-export declare const removeCameraHistory: (u: any) => any;
+declare class PointLight extends PointLightObject {
+    constructor(...options: ConstructorParameters<typeof PointLightObject>);
+    update(delta: number, elapsed: number): void;
+    render(): void;
+}
+
+declare class RectAreaLight extends RectAreaLightObject {
+    render(): void;
+}
 
-declare class Ring extends BaseObject {
+declare class Ring extends MeshObject {
+    objectType: string;
     create(): void;
 }
 
-declare class Road extends BaseObject {
-    options: Options_9;
-    constructor(options: Options_9);
-    linePrimary: Line[];
-    lineSecondary: Line[];
+declare class Road extends GroupObject {
+    objectType: string;
+    options: Options_6;
+    constructor(options: Options_6);
+    linePrimary: LineObject[];
+    lineSecondary: LineObject[];
     create(): Promise<void>;
+    rebuildFromScene(): void;
     dispose(): void;
 }
 
@@ -1677,25 +1365,49 @@ declare const sinusoidalInOut: ({ onUpdate, onComplete, backwards, }?: {
     stop: () => void;
 };
 
-declare class Sphere extends BaseObject {
+declare class Sphere extends MeshObject {
     radius: number;
-    material?: THREE.Material;
-    options?: any;
+    options: any;
+    objectType: string;
+    constructor(options: any);
     create(): void;
 }
 
-declare class SphereShadow extends BaseObject {
-    options: Required<Options_13>;
-    constructor(options: Options_13);
+declare class SphereShadow extends MeshObject {
+    objectType: string;
+    options: Required<Options_11>;
+    constructor(options: Options_11);
     create(): Promise<void>;
+    rebuildFromScene(): void;
+}
+
+declare class SpotLight extends SpotLightObject {
+    constructor(...options: ConstructorParameters<typeof SpotLightObject>);
+    update(delta: number, elapsed: number): void;
+    render(): void;
 }
 
-declare class Sprite extends BaseObject {
+declare class Sprite extends SpriteObject {
+    objectType: string;
     create(): void;
     setDesiredPixelSize(size: number): void;
 }
 
-declare class Target extends BaseObject {
+declare interface SwitchFixConfig {
+    /** 按参考缩放比缩放，并移到地图中心 */
+    s?: string[];
+    /** z 位置按缩放比缩放 */
+    z?: string[];
+    /** 移到地图顶面 */
+    t?: string[];
+    /** 移到地图底面 */
+    b?: string[];
+    /** 灯光按缩放比调整 */
+    l?: string[];
+}
+
+declare class Target extends GroupObject {
+    objectType: string;
     options: Opt;
     time: {
         value: number;
@@ -1710,6 +1422,7 @@ declare class Target extends BaseObject {
     createCylinder(texture: THREE.Texture): THREE.Object3D<THREE.Object3DEventMap>;
     createTorus(color: string): THREE.Mesh<THREE.TorusGeometry, THREE.MeshBasicMaterial, THREE.Object3DEventMap>;
     create(): Promise<void>;
+    rebuildFromScene(): void;
     erase(): void;
     update(delta: number, elapsed: number): void;
 }
@@ -1719,32 +1432,19 @@ declare class Target extends BaseObject {
  */
 declare interface TemplateConfig {
     id: string;
-    mapIndex?: number;
-    mapId?: string;
-    emissiveMapIndex?: number;
-    emmisiveMapId?: string;
+    map?: boolean;
+    emissiveMap?: boolean;
     cityOnly?: boolean;
 }
 
-declare class Tetrahedron extends BaseObject {
-    create(): void;
-}
-
 export { THREE }
 
 declare const timeOut: (ms: number) => Promise<any>;
 
-declare class Torus extends BaseObject {
-    create(): void;
-}
-
-declare class TorusKnot extends BaseObject {
-    create(): void;
-}
-
-declare class Tube extends BaseObject {
-    options: Options_2;
-    constructor(options: Options_2);
+declare class Tube extends MeshObject {
+    objectType: string;
+    options: Options_3;
+    constructor(options: Options_3);
     create(): void;
 }
 
@@ -1752,45 +1452,7 @@ export { TWEEN }
 
 export { Tween }
 
-export declare const VERSION = "0.30.14";
-
-declare class Viewport {
-    editor: Editor;
-    vis?: Base;
-    extendsOptions: Record<string, any>;
-    cameraState: Record<string, number[]>;
-    delLoadObj?: string[];
-    options: Options_6;
-    constructor(editor: Editor, options: Options_6);
-    setSaveCamera(type: string): void;
-    addVis(type: string, options?: Record<string, any>): Promise<void>;
-    replaceVis(): boolean;
-    setVis(type: string, options?: Record<string, any>): Promise<void>;
-    setResetCameraUp(): void;
-    initEvent(): void;
-    addObj(type: string, options?: Record<string, any>): Promise<void>;
-    removeObj(uuid?: string): Promise<void>;
-    private copyObjKey;
-    copyObj(key: string): void;
-    clearCopyObj(): void;
-    pasteObj(): Promise<void>;
-    copyMListMaterial(key: string): Promise<void>;
-    clearCopyMListMaterial(): Promise<void>;
-    pasteMListMaterial(): Promise<void>;
-    pasteMListMaterial2Replace(replaceKey: string): Promise<void>;
-    addMListMaterial(material?: string | Record<string, any>, object3d?: THREE.Mesh, slot?: number): Promise<string | undefined>;
-    removeMListMaterial(key: string): Promise<void>;
-    setExtendsOptions(name: string, value: any): void;
-    toJSON(): {
-        eo: Record<string, any>;
-        cs: Record<string, number[]>;
-        delLoadObj: string[] | undefined;
-    };
-    fromJSON(json: any): void;
-    getLoadObj(): string[];
-    setTransformControlsModal(modal: 'translate' | 'rotate' | 'scale'): void;
-    dispose(): void;
-}
+export declare const VERSION = "0.31.0";
 
 export { }